initial commit

node_modules/@netlify/functions/LICENSE

@@ -0,0 +1,22 @@
+Copyright (c) 2020 Netlify <team@netlify.com>
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

node_modules/@netlify/functions/README.md

@@ -0,0 +1,104 @@
+# ![functions](functions.png)
+
+[![Build](https://github.com/netlify/functions/workflows/Build/badge.svg)](https://github.com/netlify/functions/actions)
+[![Node](https://img.shields.io/node/v/@netlify/functions.svg?logo=node.js)](https://www.npmjs.com/package/@netlify/functions)
+
+JavaScript and TypeScript utilities for [Netlify Functions](https://docs.netlify.com/functions/overview/).
+
+## Installation
+
+```
+npm install @netlify/functions
+```
+
+## Usage
+
+### On-demand Builders
+
+To use On-demand Builders, wrap your function handler with the `builder` function.
+
+- With JavaScript:
+
+  ```js
+  const { builder } = require('@netlify/functions')
+
+  const handler = async (event, context) => {
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ message: 'Hello World' }),
+    }
+  }
+
+  exports.handler = builder(handler)
+  ```
+
+- With TypeScript:
+
+  ```ts
+  import { builder, Handler } from '@netlify/functions'
+
+  const myHandler: Handler = async (event, context) => {
+    return {
+      statusCode: 200,
+      body: JSON.stringify({ message: 'Hello World' }),
+    }
+  }
+
+  const handler = builder(myHandler)
+
+  export { handler }
+  ```
+
+### Scheduled Functions (currently in beta)
+
+To use Scheduled Functions, wrap your function handler with the `schedule` function.
+
+- With JavaScript:
+
+  ```js
+  const { schedule } = require('@netlify/functions')
+
+  exports.handler = schedule('5 4 * * *', async () => {
+    console.log("It's 04:05 AM!")
+  })
+  ```
+
+- With TypeScript:
+
+  ```ts
+  import { schedule } from '@netlify/functions'
+
+  export const handler = schedule("5 4 * * *", async () => {
+    console.log("It's 04:05 AM!")
+  })
+  ```
+
+### TypeScript typings
+
+This module exports typings for authoring Netlify Functions in TypeScript.
+
+```ts
+import { Handler } from '@netlify/functions'
+
+const handler: Handler = async (event, context) => {
+  return {
+    statusCode: 200,
+    body: JSON.stringify({ message: 'Hello World' }),
+  }
+}
+
+export { handler }
+```
+
+The following types are exported:
+
+- `Handler`
+- `HandlerCallback`
+- `HandlerContext`
+- `HandlerEvent`
+- `HandlerResponse`
+
+## Contributors
+
+Please see [CONTRIBUTING.md](./CONTRIBUTING.md) for instructions on how to set up and work on this repository. Thanks
+for contributing!

node_modules/@netlify/functions/dist/function/context.d.ts

@@ -0,0 +1,25 @@
+export interface Context {
+    callbackWaitsForEmptyEventLoop: boolean;
+    functionName: string;
+    functionVersion: string;
+    invokedFunctionArn: string;
+    memoryLimitInMB: string;
+    awsRequestId: string;
+    logGroupName: string;
+    logStreamName: string;
+    identity?: {
+        [key: string]: any;
+    };
+    clientContext?: {
+        [key: string]: any;
+    };
+    getRemainingTimeInMillis(): number;
+    /** @deprecated Use handler callback or promise result */
+    done(error?: Error, result?: any): void;
+    /** @deprecated Use handler callback with first argument or reject a promise result */
+    fail(error: Error | string): void;
+    /** @deprecated Use handler callback with second argument or resolve a promise result */
+    succeed(messageOrObject: any): void;
+    /** @deprecated Use handler callback or promise result */
+    succeed(message: string, object: any): void;
+}

node_modules/@netlify/functions/dist/function/context.js

@@ -0,0 +1,4 @@
+"use strict";
+// eslint-disable-next-line eslint-comments/disable-enable-pair
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@netlify/functions/dist/function/event.d.ts

@@ -0,0 +1,26 @@
+interface EventHeaders {
+    [name: string]: string | undefined;
+}
+interface EventMultiValueHeaders {
+    [name: string]: string[] | undefined;
+}
+interface EventQueryStringParameters {
+    [name: string]: string | undefined;
+}
+interface EventMultiValueQueryStringParameters {
+    [name: string]: string[] | undefined;
+}
+export interface Event {
+    rawUrl: string;
+    rawQuery: string;
+    path: string;
+    httpMethod: string;
+    headers: EventHeaders;
+    multiValueHeaders: EventMultiValueHeaders;
+    queryStringParameters: EventQueryStringParameters | null;
+    multiValueQueryStringParameters: EventMultiValueQueryStringParameters | null;
+    body: string | null;
+    isBase64Encoded: boolean;
+    netlifyGraphToken: string | undefined;
+}
+export {};

node_modules/@netlify/functions/dist/function/event.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@netlify/functions/dist/function/handler.d.ts

@@ -0,0 +1,14 @@
+import type { Context } from './context.js';
+import type { Event } from './event.js';
+import type { Response, BuilderResponse } from './response.js';
+export interface HandlerCallback<ResponseType extends Response = Response> {
+    (error: any, response: ResponseType): void;
+}
+export interface BaseHandler<ResponseType extends Response = Response, C extends Context = Context> {
+    (event: Event, context: C, callback?: HandlerCallback<ResponseType>): void | Promise<ResponseType>;
+}
+export interface BackgroundHandler<C extends Context = Context> {
+    (event: Event, context: C): void | Promise<void>;
+}
+export declare type Handler = BaseHandler<Response, Context>;
+export declare type BuilderHandler = BaseHandler<BuilderResponse, Context>;

node_modules/@netlify/functions/dist/function/handler.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

node_modules/@netlify/functions/dist/function/index.d.ts

@@ -0,0 +1,6 @@
+export { Context as HandlerContext } from './context.js';
+export { Event as HandlerEvent } from './event.js';
+export { Handler, BackgroundHandler, HandlerCallback } from './handler.js';
+export { Response as HandlerResponse } from './response.js';
+export { getSecrets, getSecretsForBuild, withSecrets, getNetlifyGraphToken, getNetlifyGraphTokenForBuild, GraphTokenResponse, HasHeaders, } from '../lib/graph.js';
+export { NetlifySecrets } from '../lib/secrets_helper.js';

node_modules/@netlify/functions/dist/function/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNetlifyGraphTokenForBuild = exports.getNetlifyGraphToken = exports.withSecrets = exports.getSecretsForBuild = exports.getSecrets = void 0;
+var graph_js_1 = require("../lib/graph.js");
+Object.defineProperty(exports, "getSecrets", { enumerable: true, get: function () { return graph_js_1.getSecrets; } });
+Object.defineProperty(exports, "getSecretsForBuild", { enumerable: true, get: function () { return graph_js_1.getSecretsForBuild; } });
+Object.defineProperty(exports, "withSecrets", { enumerable: true, get: function () { return graph_js_1.withSecrets; } });
+Object.defineProperty(exports, "getNetlifyGraphToken", { enumerable: true, get: function () { return graph_js_1.getNetlifyGraphToken; } });
+Object.defineProperty(exports, "getNetlifyGraphTokenForBuild", { enumerable: true, get: function () { return graph_js_1.getNetlifyGraphTokenForBuild; } });

node_modules/@netlify/functions/dist/function/response.d.ts

@@ -0,0 +1,14 @@
+export interface Response {
+    statusCode: number;
+    headers?: {
+        [header: string]: boolean | number | string;
+    };
+    multiValueHeaders?: {
+        [header: string]: ReadonlyArray<boolean | number | string>;
+    };
+    body?: string;
+    isBase64Encoded?: boolean;
+}
+export interface BuilderResponse extends Response {
+    ttl?: number;
+}

node_modules/@netlify/functions/dist/function/response.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

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;

node_modules/@netlify/functions/dist/main.d.ts

@@ -0,0 +1,3 @@
+export { builder } from './lib/builder.js';
+export { schedule } from './lib/schedule.js';
+export * from './function/index.js';

node_modules/@netlify/functions/dist/main.js

@@ -0,0 +1,22 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.schedule = exports.builder = void 0;
+var builder_js_1 = require("./lib/builder.js");
+Object.defineProperty(exports, "builder", { enumerable: true, get: function () { return builder_js_1.builder; } });
+var schedule_js_1 = require("./lib/schedule.js");
+Object.defineProperty(exports, "schedule", { enumerable: true, get: function () { return schedule_js_1.schedule; } });
+__exportStar(require("./function/index.js"), exports);

node_modules/@netlify/functions/package.json

@@ -0,0 +1,71 @@
+{
+  "name": "@netlify/functions",
+  "main": "./dist/main.js",
+  "types": "./dist/main.d.ts",
+  "version": "1.3.0",
+  "description": "JavaScript utilities for Netlify Functions",
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.d.ts"
+  ],
+  "scripts": {
+    "build": "tsc",
+    "prepare": "husky install node_modules/@netlify/eslint-config-node/.husky/",
+    "prepack": "npm run build",
+    "prepublishOnly": "npm ci && npm test",
+    "test": "run-s format test:dev",
+    "format": "run-s build format:check-fix:*",
+    "format:ci": "run-s build format:check:*",
+    "format:check-fix:lint": "run-e format:check:lint format:fix:lint",
+    "format:check:lint": "cross-env-shell eslint $npm_package_config_eslint",
+    "format:fix:lint": "cross-env-shell eslint --fix $npm_package_config_eslint",
+    "format:check-fix:prettier": "run-e format:check:prettier format:fix:prettier",
+    "format:check:prettier": "cross-env-shell prettier --check $npm_package_config_prettier",
+    "format:fix:prettier": "cross-env-shell prettier --write $npm_package_config_prettier",
+    "test:dev": "run-s build test:dev:*",
+    "test:ci": "run-s build test:ci:*",
+    "test:dev:ava": "ava",
+    "test:dev:tsd": "tsd",
+    "test:ci:ava": "nyc -r lcovonly -r text -r json ava"
+  },
+  "config": {
+    "eslint": "--ignore-pattern README.md --ignore-path .gitignore --cache --format=codeframe --max-warnings=0 \"{src,scripts,.github,test}/**/*.{ts,js,md,html}\" \"*.{ts,js,md,html}\" \".*.{ts,js,md,html}\"",
+    "prettier": "--ignore-path .gitignore --loglevel=warn \"{src,scripts,.github}/**/*.{ts,js,md,yml,json,html}\" \"*.{ts,js,yml,json,html}\" \".*.{ts,js,yml,json,html}\" \"!**/package-lock.json\" \"!package-lock.json\""
+  },
+  "ava": {
+    "files": [
+      "test/unit/*.js"
+    ],
+    "verbose": true
+  },
+  "tsd": {
+    "directory": "test/types/"
+  },
+  "keywords": [],
+  "license": "MIT",
+  "repository": "netlify/functions",
+  "bugs": {
+    "url": "https://github.com/netlify/functions/issues"
+  },
+  "author": "Netlify Inc.",
+  "directories": {
+    "test": "test"
+  },
+  "dependencies": {
+    "is-promise": "^4.0.0"
+  },
+  "devDependencies": {
+    "@commitlint/cli": "^13.0.0",
+    "@commitlint/config-conventional": "^13.0.0",
+    "@netlify/eslint-config-node": "^7.0.0",
+    "ava": "^2.4.0",
+    "husky": "^7.0.4",
+    "npm-run-all": "^4.1.5",
+    "nyc": "^15.0.0",
+    "tsd": "^0.24.1",
+    "typescript": "^4.4.4"
+  },
+  "engines": {
+    "node": ">=8.3.0"
+  }
+}