initial commit

node_modules/@netlify/functions/dist/lib/builder.d.ts

@@ -0,0 +1,3 @@
+import { BuilderHandler, Handler } from '../function/handler.js';
+declare const wrapHandler: (handler: BuilderHandler) => Handler;
+export { wrapHandler as builder };

node_modules/@netlify/functions/dist/lib/builder.js

@@ -0,0 +1,50 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.builder = void 0;
+var is_promise_1 = __importDefault(require("is-promise"));
+var consts_js_1 = require("./consts.js");
+var augmentResponse = function (response) {
+    if (!response) {
+        return response;
+    }
+    var metadata = { version: consts_js_1.METADATA_VERSION, builder_function: consts_js_1.BUILDER_FUNCTIONS_FLAG, ttl: response.ttl || 0 };
+    return __assign(__assign({}, response), { metadata: metadata });
+};
+var wrapHandler = function (handler) {
+    // eslint-disable-next-line promise/prefer-await-to-callbacks
+    return function (event, context, callback) {
+        if (event.httpMethod !== 'GET' && event.httpMethod !== 'HEAD') {
+            return Promise.resolve({
+                body: 'Method Not Allowed',
+                statusCode: consts_js_1.HTTP_STATUS_METHOD_NOT_ALLOWED,
+            });
+        }
+        // Removing query string parameters from the builder function.
+        var modifiedEvent = __assign(__assign({}, event), { multiValueQueryStringParameters: {}, queryStringParameters: {} });
+        var wrappedCallback = function (error, response) {
+            // eslint-disable-next-line promise/prefer-await-to-callbacks
+            return callback ? callback(error, augmentResponse(response)) : null;
+        };
+        var execution = handler(modifiedEvent, context, wrappedCallback);
+        if ((0, is_promise_1.default)(execution)) {
+            // eslint-disable-next-line promise/prefer-await-to-then
+            return execution.then(augmentResponse);
+        }
+        return execution;
+    };
+};
+exports.builder = wrapHandler;

node_modules/@netlify/functions/dist/lib/consts.d.ts

@@ -0,0 +1,5 @@
+declare const BUILDER_FUNCTIONS_FLAG = true;
+declare const HTTP_STATUS_METHOD_NOT_ALLOWED = 405;
+declare const HTTP_STATUS_OK = 200;
+declare const METADATA_VERSION = 1;
+export { BUILDER_FUNCTIONS_FLAG, HTTP_STATUS_METHOD_NOT_ALLOWED, HTTP_STATUS_OK, METADATA_VERSION };

node_modules/@netlify/functions/dist/lib/consts.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.METADATA_VERSION = exports.HTTP_STATUS_OK = exports.HTTP_STATUS_METHOD_NOT_ALLOWED = exports.BUILDER_FUNCTIONS_FLAG = void 0;
+var BUILDER_FUNCTIONS_FLAG = true;
+exports.BUILDER_FUNCTIONS_FLAG = BUILDER_FUNCTIONS_FLAG;
+var HTTP_STATUS_METHOD_NOT_ALLOWED = 405;
+exports.HTTP_STATUS_METHOD_NOT_ALLOWED = HTTP_STATUS_METHOD_NOT_ALLOWED;
+var HTTP_STATUS_OK = 200;
+exports.HTTP_STATUS_OK = HTTP_STATUS_OK;
+var METADATA_VERSION = 1;
+exports.METADATA_VERSION = METADATA_VERSION;

node_modules/@netlify/functions/dist/lib/graph.d.ts

@@ -0,0 +1,12 @@
+import { Context as HandlerContext, Context } from '../function/context.js';
+import { Event as HandlerEvent } from '../function/event.js';
+import { BaseHandler, HandlerCallback } from '../function/handler.js';
+import { Response } from '../function/response.js';
+import { NetlifySecrets } from './secrets_helper.js';
+export { getSecrets, getSecretsForBuild } from './secrets_helper.js';
+export { getNetlifyGraphToken, getNetlifyGraphTokenForBuild, GraphTokenResponse, HasHeaders } from './graph_token.js';
+export interface ContextWithSecrets extends Context {
+    secrets: NetlifySecrets;
+}
+export declare type HandlerWithSecrets = BaseHandler<Response, ContextWithSecrets>;
+export declare const withSecrets: (handler: BaseHandler<Response, ContextWithSecrets>) => (event: HandlerEvent, context: HandlerContext, callback: HandlerCallback<Response>) => Promise<void | Response>;

node_modules/@netlify/functions/dist/lib/graph.js

@@ -0,0 +1,75 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withSecrets = exports.getNetlifyGraphTokenForBuild = exports.getNetlifyGraphToken = exports.getSecretsForBuild = exports.getSecrets = void 0;
+var secrets_helper_js_1 = require("./secrets_helper.js");
+// Fine-grained control during the preview, less necessary with a more proactive OneGraph solution
+var secrets_helper_js_2 = require("./secrets_helper.js");
+Object.defineProperty(exports, "getSecrets", { enumerable: true, get: function () { return secrets_helper_js_2.getSecrets; } });
+Object.defineProperty(exports, "getSecretsForBuild", { enumerable: true, get: function () { return secrets_helper_js_2.getSecretsForBuild; } });
+var graph_token_js_1 = require("./graph_token.js");
+Object.defineProperty(exports, "getNetlifyGraphToken", { enumerable: true, get: function () { return graph_token_js_1.getNetlifyGraphToken; } });
+Object.defineProperty(exports, "getNetlifyGraphTokenForBuild", { enumerable: true, get: function () { return graph_token_js_1.getNetlifyGraphTokenForBuild; } });
+// The common usage of this module
+var withSecrets = function (handler) {
+    return function (event, context, 
+    // eslint-disable-next-line promise/prefer-await-to-callbacks
+    callback) { return __awaiter(void 0, void 0, void 0, function () {
+        var secrets;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, (0, secrets_helper_js_1.getSecrets)(event)];
+                case 1:
+                    secrets = _a.sent();
+                    return [2 /*return*/, handler(event, __assign(__assign({}, context), { secrets: secrets }), callback)];
+            }
+        });
+    }); };
+};
+exports.withSecrets = withSecrets;

node_modules/@netlify/functions/dist/lib/graph_request.d.ts

@@ -0,0 +1 @@
+export declare const graphRequest: (secretToken: string, requestBody: Uint8Array) => Promise<string>;

node_modules/@netlify/functions/dist/lib/graph_request.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphRequest = void 0;
+var buffer_1 = require("buffer");
+var https_1 = require("https");
+var process_1 = require("process");
+var siteId = process_1.env.SITE_ID;
+var GRAPH_HOST = 'graph.netlify.com';
+var graphRequest = function (secretToken, requestBody) {
+    return new Promise(function (resolve, reject) {
+        var port = 443;
+        var options = {
+            host: GRAPH_HOST,
+            path: "/graphql?app_id=".concat(siteId),
+            port: port,
+            method: 'POST',
+            headers: {
+                Authorization: "Bearer ".concat(secretToken),
+                'Content-Type': 'application/json',
+                Accept: 'application/json',
+                'Content-Length': requestBody ? buffer_1.Buffer.byteLength(requestBody) : 0,
+            },
+        };
+        var req = (0, https_1.request)(options, function (res) {
+            if (res.statusCode !== 200) {
+                return reject(new Error(String(res.statusCode)));
+            }
+            var body = [];
+            res.on('data', function (chunk) {
+                body.push(chunk);
+            });
+            res.on('end', function () {
+                var data = buffer_1.Buffer.concat(body).toString();
+                try {
+                    resolve(data);
+                }
+                catch (error) {
+                    reject(error);
+                }
+            });
+        });
+        req.on('error', function (error) {
+            reject(error);
+        });
+        req.write(requestBody);
+        req.end();
+    });
+};
+exports.graphRequest = graphRequest;

node_modules/@netlify/functions/dist/lib/graph_token.d.ts

@@ -0,0 +1,20 @@
+export declare type GraphTokenResponseError = {
+    type: 'missing-event-in-function' | 'provided-event-in-build';
+    message: string;
+};
+export declare type GraphTokenResponse = {
+    errors?: GraphTokenResponseError[];
+    token?: string | null;
+};
+interface RequestHeaders {
+    get(name: string): string | null;
+}
+interface IncomingHttpHeaders {
+    [key: string]: string | string[] | undefined;
+}
+export interface HasHeaders {
+    headers: RequestHeaders | IncomingHttpHeaders;
+}
+export declare const getNetlifyGraphToken: (event?: HasHeaders | null | undefined, supressLog?: boolean) => GraphTokenResponse;
+export declare const getNetlifyGraphTokenForBuild: () => GraphTokenResponse;
+export {};

node_modules/@netlify/functions/dist/lib/graph_token.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNetlifyGraphTokenForBuild = exports.getNetlifyGraphToken = void 0;
+var process_1 = require("process");
+var TOKEN_HEADER = 'X-Nf-Graph-Token';
+var TOKEN_HEADER_NORMALIZED = 'x-nf-graph-token';
+var hasRequestStyleHeaders = function (headers) {
+    return headers.get !== undefined && typeof headers.get === 'function';
+};
+var graphTokenFromIncomingHttpStyleHeaders = function (headers) {
+    if (TOKEN_HEADER in headers || TOKEN_HEADER_NORMALIZED in headers) {
+        var header = headers[TOKEN_HEADER] || headers[TOKEN_HEADER_NORMALIZED];
+        if (Array.isArray(header)) {
+            return header[0];
+        }
+        return header;
+    }
+};
+var graphTokenFromEnv = function () {
+    // _NETLIFY_GRAPH_TOKEN injected by next plugin
+    // eslint-disable-next-line no-underscore-dangle
+    var token = process_1.env._NETLIFY_GRAPH_TOKEN || process_1.env.NETLIFY_GRAPH_TOKEN;
+    return { token: token };
+};
+var tokenFallback = function (event) {
+    // Backwards compatibility with older version of cli that doesn't inject header
+    if (event && event.authlifyToken) {
+        return { token: event.authlifyToken };
+    }
+    // If we're in dev-mode with next.js, the plugin won't be there to inject
+    // secrets, so we need to get the token from the environment
+    if (process_1.env.NETLIFY_DEV === 'true') {
+        return graphTokenFromEnv();
+    }
+    return { token: null };
+};
+var graphTokenFromEvent = function (event) {
+    var headers = event.headers;
+    // Check if object first in case there is a header with key `get`
+    var token = graphTokenFromIncomingHttpStyleHeaders(headers);
+    if (token) {
+        return { token: token };
+    }
+    if (hasRequestStyleHeaders(headers)) {
+        return { token: headers.get(TOKEN_HEADER) };
+    }
+    return tokenFallback(event);
+};
+var isEventRequired = function () {
+    var localDev = process_1.env.NETLIFY_DEV === 'true';
+    var localBuild = !localDev && process_1.env.NETLIFY_LOCAL === 'true';
+    var remoteBuild = process_1.env.NETLIFY === 'true';
+    // neither `localBuild` nor `remoteBuild` will be true in the on-demand builder case
+    var inBuildPhase = localBuild || remoteBuild;
+    var inGetStaticProps = 
+    // Set by the nextjs plugin
+    // eslint-disable-next-line no-underscore-dangle
+    typeof process_1.env._NETLIFY_GRAPH_TOKEN !== 'undefined';
+    return !inBuildPhase && !inGetStaticProps;
+};
+var incorrectArgumentsErrors = function (event) {
+    var requiresEvent = isEventRequired();
+    if (requiresEvent && event == null) {
+        var errorMessage = 'You must provide an event or request to `getNetlifyGraphToken` when used in functions and on-demand builders.';
+        return [{ type: 'missing-event-in-function', message: errorMessage }];
+    }
+    if (!requiresEvent && event != null) {
+        var errorMessage = 'You must not pass arguments to `getNetlifyGraphToken` when used in builds.';
+        return [{ type: 'provided-event-in-build', message: errorMessage }];
+    }
+};
+var logErrors = function (errors) {
+    for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
+        var error = errors_1[_i];
+        // Log errors to help guide developer
+        console.error(error.message);
+    }
+};
+var getNetlifyGraphToken = function (event, 
+// caller can prevent error log. Allows getSecrets to provide better errors
+supressLog) {
+    var errors = incorrectArgumentsErrors(event);
+    if (errors) {
+        if (!supressLog) {
+            logErrors(errors);
+        }
+        return { errors: errors };
+    }
+    return event ? graphTokenFromEvent(event) : graphTokenFromEnv();
+};
+exports.getNetlifyGraphToken = getNetlifyGraphToken;
+var getNetlifyGraphTokenForBuild = function () {
+    return graphTokenFromEnv();
+};
+exports.getNetlifyGraphTokenForBuild = getNetlifyGraphTokenForBuild;

node_modules/@netlify/functions/dist/lib/schedule.d.ts

@@ -0,0 +1,18 @@
+import type { Handler } from '../function/index.js';
+/**
+ * Declares a function to run on a cron schedule.
+ * Not reachable via HTTP.
+ *
+ * @example
+ * ```
+ * export const handler = cron("5 4 * * *", async () => {
+ *   // ...
+ * })
+ * ```
+ *
+ * @param schedule expressed as cron string.
+ * @param handler
+ * @see https://ntl.fyi/sched-func
+ */
+declare const schedule: (cron: string, handler: Handler) => Handler;
+export { schedule };

node_modules/@netlify/functions/dist/lib/schedule.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schedule = void 0;
+/**
+ * Declares a function to run on a cron schedule.
+ * Not reachable via HTTP.
+ *
+ * @example
+ * ```
+ * export const handler = cron("5 4 * * *", async () => {
+ *   // ...
+ * })
+ * ```
+ *
+ * @param schedule expressed as cron string.
+ * @param handler
+ * @see https://ntl.fyi/sched-func
+ */
+var schedule = function (cron, handler) { return handler; };
+exports.schedule = schedule;

node_modules/@netlify/functions/dist/lib/secrets_helper.d.ts

@@ -0,0 +1,36 @@
+import { HasHeaders } from './graph_token.js';
+declare const services: {
+    gitHub: null;
+    spotify: null;
+    salesforce: null;
+    stripe: null;
+};
+export declare type Service = {
+    friendlyServiceName: string;
+    service: string;
+    isLoggedIn: boolean;
+    bearerToken: string | null;
+    grantedScopes: Array<{
+        scope: string;
+        scopeInfo: {
+            category: string | null;
+            scope: string;
+            display: string;
+            isDefault: boolean;
+            isRequired: boolean;
+            description: string | null;
+            title: string | null;
+        };
+    }> | null;
+};
+export declare type Services = typeof services;
+export declare type ServiceKey = keyof Services;
+export declare type ServiceTokens = Service;
+export declare type NetlifySecrets = {
+    [K in ServiceKey]?: Service;
+} & {
+    [key: string]: Service;
+};
+export declare const getSecrets: (event?: HasHeaders | null | undefined) => Promise<NetlifySecrets>;
+export declare const getSecretsForBuild: () => Promise<NetlifySecrets>;
+export {};

node_modules/@netlify/functions/dist/lib/secrets_helper.js

@@ -0,0 +1,166 @@
+"use strict";
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSecretsForBuild = exports.getSecrets = void 0;
+var graph_request_js_1 = require("./graph_request.js");
+var graph_token_js_1 = require("./graph_token.js");
+var services = {
+    gitHub: null,
+    spotify: null,
+    salesforce: null,
+    stripe: null,
+};
+var camelize = function (text) {
+    var safe = text.replace(/[-_\s.]+(.)?/g, function (_, sub) { return (sub ? sub.toUpperCase() : ''); });
+    return safe.slice(0, 1).toLowerCase() + safe.slice(1);
+};
+// The services will be camelized versions of the OneGraph service enums
+// unless overridden by the serviceNormalizeOverrides object
+var serviceNormalizeOverrides = {
+    // Keys are the OneGraph service enums, values are the desired `secret.<service>` names
+    GITHUB: 'gitHub',
+};
+var formatSecrets = function (result) {
+    if (!result ||
+        !result.data ||
+        !result.data.me ||
+        !result.data.me.serviceMetadata ||
+        !result.data.me.serviceMetadata.loggedInServices) {
+        return {};
+    }
+    // TODO use optional chaining once we drop node 12 or lower
+    var responseServices = result.data.me.serviceMetadata.loggedInServices;
+    var newSecrets = responseServices.reduce(function (acc, service) {
+        var _a;
+        var normalized = serviceNormalizeOverrides[service.service] || camelize(service.friendlyServiceName);
+        return __assign(__assign({}, acc), (_a = {}, _a[normalized] = service, _a));
+    }, {});
+    return newSecrets;
+};
+var logErrors = function (errors) {
+    for (var _i = 0, errors_1 = errors; _i < errors_1.length; _i++) {
+        var error = errors_1[_i];
+        var errorMessage = void 0;
+        switch (error.type) {
+            case 'missing-event-in-function':
+                errorMessage =
+                    'You must provide an event or request to `getSecrets` when used in functions and on-demand builders.';
+                break;
+            case 'provided-event-in-build':
+                errorMessage = 'You must not pass arguments to `getSecrets` when used in builds.';
+                break;
+            default: {
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+                var exhaustiveCheck = error.type;
+                errorMessage = error.type;
+                break;
+            }
+        }
+        var message = errorMessage;
+        console.error(message);
+    }
+};
+// We select for more than we typically need here
+// in order to allow for some metaprogramming for
+// consumers downstream. Also, the data is typically
+// static and shouldn't add any measurable overhead.
+var findLoggedInServicesQuery = "query FindLoggedInServicesQuery {\n    me {\n      serviceMetadata {\n        loggedInServices {\n          friendlyServiceName\n          service\n          isLoggedIn\n          bearerToken\n          grantedScopes {\n            scope\n            scopeInfo {\n              category\n              scope\n              display\n              isDefault\n              isRequired\n              description\n              title\n            }\n          }\n        }\n      }\n    }\n  }";
+var getSecretsForToken = function (token) { return __awaiter(void 0, void 0, void 0, function () {
+    var body, resultBody, result, newSecrets;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                body = JSON.stringify({ query: findLoggedInServicesQuery });
+                return [4 /*yield*/, (0, graph_request_js_1.graphRequest)(token, new TextEncoder().encode(body))];
+            case 1:
+                resultBody = _a.sent();
+                result = JSON.parse(resultBody);
+                newSecrets = formatSecrets(result);
+                return [2 /*return*/, newSecrets];
+        }
+    });
+}); };
+var getSecrets = function (event) { return __awaiter(void 0, void 0, void 0, function () {
+    var graphTokenResponse, graphToken;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                graphTokenResponse = (0, graph_token_js_1.getNetlifyGraphToken)(event, true);
+                graphToken = graphTokenResponse.token;
+                if (!graphToken) {
+                    if (graphTokenResponse.errors) {
+                        logErrors(graphTokenResponse.errors);
+                    }
+                    return [2 /*return*/, {}];
+                }
+                return [4 /*yield*/, getSecretsForToken(graphToken)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.getSecrets = getSecrets;
+var getSecretsForBuild = function () { return __awaiter(void 0, void 0, void 0, function () {
+    var graphTokenResponse, graphToken;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                graphTokenResponse = (0, graph_token_js_1.getNetlifyGraphTokenForBuild)();
+                graphToken = graphTokenResponse.token;
+                if (!graphToken) {
+                    if (graphTokenResponse.errors) {
+                        logErrors(graphTokenResponse.errors);
+                    }
+                    return [2 /*return*/, {}];
+                }
+                return [4 /*yield*/, getSecretsForToken(graphToken)];
+            case 1: return [2 /*return*/, _a.sent()];
+        }
+    });
+}); };
+exports.getSecretsForBuild = getSecretsForBuild;