mastra 0.1.57-alpha.9 → 0.1.57-unstable.35

package/node_modules/express-jsdoc-swagger/transforms/utils/httpMethods.js

@@ -0,0 +1,18 @@
+const validRequestBodyMethods = {
+  get: false,
+  delete: true,
+  head: false,
+  post: true,
+  put: true,
+  connect: true,
+  options: true,
+  trace: true,
+  patch: true,
+};
+
+const validHTTPMethod = method => Object.keys(validRequestBodyMethods).includes(method);
+
+module.exports = {
+  validRequestBodyMethods,
+  validHTTPMethod,
+};

package/node_modules/express-jsdoc-swagger/transforms/utils/mapDescription.js

@@ -0,0 +1,5 @@
+const DECRIPTION_DIVIDER = ' - ';
+
+const mapDescription = description => (description || '').split(DECRIPTION_DIVIDER);
+
+module.exports = mapDescription;

package/node_modules/express-jsdoc-swagger/transforms/utils/refSchema.js

@@ -0,0 +1,48 @@
+const validateTypes = require('./validateTypes');
+
+const REF_ROUTE = '#/components/schemas/';
+
+const refSchema = value => {
+  // support * @return {array<Song|Album>} 200 - fetch Home Content response
+  if (value && value.type === 'UnionType') {
+    const items = [];
+    value.elements.forEach(el => {
+      const isPrimitiveType = validateTypes(el.name);
+      items.push(isPrimitiveType ? { type: el.name } : { $ref: `${REF_ROUTE}${el.name}` });
+    });
+    return {
+      anyOf: items,
+    };
+  }
+
+  // support * @property {anyOf|Song[]|Album|string|string[]} firstSong
+  if (value && value.expression && value.expression.name.toLowerCase() === 'array' && value.type === 'TypeApplication') {
+    const isPrimitiveType = validateTypes(value.applications[0].name);
+    return isPrimitiveType ? {
+      type: 'array',
+      items: { type: value.applications[0].name },
+    } : {
+      type: 'array',
+      items: { $ref: `${REF_ROUTE}${value.applications[0].name}` },
+    };
+  }
+
+  if (!value) return {};
+
+  const nameValue = value.name || value;
+  // support null
+  if (nameValue.type === 'NullLiteral') return { nullable: true };
+
+  const isPrimitive = validateTypes(nameValue);
+  return isPrimitive ? { type: nameValue } : { $ref: `${REF_ROUTE}${nameValue}` };
+};
+
+const formatRefSchema = (applications = []) => applications.reduce((itemAcc, itemTypes) => ({
+  ...itemAcc,
+  ...refSchema(itemTypes),
+}), {});
+
+module.exports = {
+  refSchema,
+  formatRefSchema,
+};

package/node_modules/express-jsdoc-swagger/transforms/utils/setProperty.js

@@ -0,0 +1,25 @@
+const errorMessage = require('./errorMessage');
+
+const setProperty = entity => {
+  const requiredError = (key, item) => (
+    new Error(`Key ${key} is required in item ${JSON.stringify(item)} for Entity ${entity}`)
+  );
+
+  const warnType = (type, value) => (
+    errorMessage(`${type} is not valid with value ${value} for Entity ${entity}`)
+  );
+
+  return (item, key, options) => {
+    if (!item || !key || !options) {
+      throw (new Error('item, key and options para are required'));
+    }
+    const value = item[key];
+    if (options.required && value === undefined) throw requiredError(key, item);
+    if (value === undefined || value === null) return options.defaultValue;
+    // eslint-disable-next-line
+    if (typeof (value) !== options.type) warnType(options.type, value);
+    return value;
+  };
+};
+
+module.exports = setProperty;

package/node_modules/express-jsdoc-swagger/transforms/utils/tags.js

@@ -0,0 +1,16 @@
+const mapDescription = require('./mapDescription');
+
+const getTagInfo = (tags, key) => tags.find(({ title }) => title === key);
+
+const getTagsInfo = (tags, key) => tags.filter(({ title }) => title === key);
+
+const formatDescriptionTag = desc => {
+  const [name, description] = mapDescription(desc);
+  return { name, description };
+};
+
+module.exports = {
+  getTagInfo,
+  getTagsInfo,
+  formatDescriptionTag,
+};

package/node_modules/express-jsdoc-swagger/transforms/utils/validateTypes.js

@@ -0,0 +1,11 @@
+const TYPES = [
+  'integer',
+  'number',
+  'string',
+  'boolean',
+  'object',
+];
+
+const validateTypes = type => TYPES.includes(type);
+
+module.exports = validateTypes;

package/node_modules/serverless-http/LICENSE.txt

@@ -0,0 +1,33 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Doug Moscrop
+
+The following license applies to all parts of this software except as
+documented below:
+
+====
+
+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.
+
+====
+
+All files located in the node_modules and external directories are
+externally maintained libraries used by this software which have their
+own licenses; we recommend you read them, as their terms may differ from
+the terms above.

package/node_modules/serverless-http/README.md

@@ -0,0 +1,117 @@
+# serverless-http
+
+[![Build Status](https://travis-ci.org/dougmoscrop/serverless-http.svg?branch=master)](https://travis-ci.org/dougmoscrop/serverless-http)
+
+## Description
+
+This module allows you to 'wrap' your API for serverless use. No HTTP server, no ports or sockets. Just your code in the same execution pipeline you are already familiar with.
+
+## Sponsors
+
+Thank you to Upstash for reaching out to sponsor this project!
+
+<table>
+<tr>
+<td>
+  <img width="1000" height="0">
+  <a href="https://upstash.com/?utm_source=serverless-http" >
+  <img src="https://raw.githubusercontent.com/upstash/sponsorship/master/redis.png" alt="Upstash" width="260" align="right">
+  </a>
+<h3>Upstash: Serverless Database for Redis</h3>
+
+  <ul>
+    <li>Serverless Redis with global replication and durable storage</li>
+    <li>Price scales to zero with per request pricing</li>
+    <li>Built-in REST API designed for serverless and edge functions</li>
+  </ul>
+  
+[Start for free in 30 seconds!](https://upstash.com/?utm_source=serverless-http)
+</td>
+</tr>
+</table>
+
+## Support
+
+### Supported Frameworks
+(* Experimental)
+
+* Node (http.createServer)
+* Connect
+* Express
+* Koa
+* Restana
+* Sails *
+* Hapi *
+* Fastify *
+* Restify *
+* Polka *
+* Loopback *
+
+### Supported Providers
+
+* AWS
+* Azure (Experimental, untested, probably outdated)
+
+## Examples
+
+Please check the `examples` folder!
+
+### Usage example using the Koa framework
+
+```javascript
+const serverless = require('serverless-http');
+const Koa = require('koa'); // or any supported framework
+
+const app = new Koa();
+
+app.use(/* register your middleware as normal */);
+
+// this is it!
+module.exports.handler = serverless(app);
+
+// or as a promise
+const handler = serverless(app);
+module.exports.handler = async (event, context) => {
+  // you can do other things here
+  const result = await handler(event, context);
+  // and here
+  return result;
+};
+```
+
+### Usage example using the Express framework with Azure
+
+```javascript
+
+const serverless = require('serverless-http');
+const express = require('express');
+
+const app = express();
+
+app.use(/* register your middleware as normal */);
+
+const handler = serverless(app, { provider: 'azure' });
+module.exports.funcName = async (context, req) => {
+  context.res = await handler(context, req);
+}
+
+```
+
+### Other examples
+[json-server-less-λ](https://github.com/pharindoko/json-server-less-lambda) - using serverless-http with json-server and serverless framework in AWS
+
+
+## Limitations
+
+Your code is running in a serverless environment. You cannot rely on your server being 'up' in the sense that you can/should not use in-memory sessions, web sockets, etc. You are also subject to provider specific restrictions on request/response size, duration, etc.
+
+> Think of this as a familiar way of expressing your app logic, *not* trying to make serverless do something it cannot.
+
+## Contributing
+
+Pull requests are welcome! Especially test scenarios for different situations and configurations.
+
+## Further Reading
+
+Here are some [more detailed examples](./docs/EXAMPLES.md) and [advanced configuration options](./docs/ADVANCED.md) as well as [provider-specific documentation](./docs/PROVIDERS.md)
+

package/node_modules/serverless-http/lib/finish.js

@@ -0,0 +1,42 @@
+'use strict';
+
+module.exports = async function finish(item, transform, ...details) {
+  await new Promise((resolve, reject) => {
+    if (item.finished || item.complete) {
+      resolve();
+      return;
+    }
+
+    let finished = false;
+
+    function done(err) {
+      if (finished) {
+        return;
+      }
+
+      finished = true;
+
+      item.removeListener('error', done);
+      item.removeListener('end', done);
+      item.removeListener('finish', done);
+
+      if (err) {
+        reject(err);
+      } else {
+        resolve();
+      }
+    }
+
+    item.once('error', done);
+    item.once('end', done);
+    item.once('finish', done);
+  });
+
+  if (typeof transform === 'function') {
+    await transform(item, ...details);
+  } else if (typeof transform === 'object' && transform !== null) {
+    Object.assign(item, transform);
+  }
+
+  return item;
+};

package/node_modules/serverless-http/lib/framework/get-framework.js

@@ -0,0 +1,79 @@
+'use strict';
+
+const http = require('http')
+const Response = require('../response');
+
+function common(cb) {
+  return request => {
+    const response = new Response(request);
+
+    cb(request, response);
+
+    return response;
+  };
+}
+
+module.exports = function getFramework(app) {
+  if (app instanceof http.Server) {
+    return request => {
+      const response = new Response(request);
+      app.emit('request', request, response)
+      return response
+    }
+  }
+
+  if (typeof app.callback === 'function') {
+    return common(app.callback());
+  }
+
+  if (typeof app.handle === 'function') {
+    return common((request, response) => {
+      app.handle(request, response);
+    });
+  }
+
+  if (typeof app.handler === 'function') {
+    return common((request, response) => {
+      app.handler(request, response);
+    });
+  }
+
+  if (typeof app._onRequest === 'function') {
+    return common((request, response) => {
+      app._onRequest(request, response);
+    });
+  }
+
+  if (typeof app === 'function') {
+    return common(app);
+  }
+
+  if (app.router && typeof app.router.route == 'function') {
+    return common((req, res) => {
+      const { url, method, headers, body } = req;
+      app.router.route({ url, method, headers, body }, res);
+    });
+  }
+
+  if (app._core && typeof app._core._dispatch === 'function') {
+    return common(app._core._dispatch({
+      app
+    }));
+  }
+
+  if (typeof app.inject === 'function') {
+    return async request => {
+      const { method, url, headers, body } = request;
+
+      const res = await app.inject({ method, url, headers, payload: body })
+
+      return Response.from(res);
+    };
+  }
+
+  if (typeof app.main === 'function') {
+    return common(app.main);
+  }
+
+  throw new Error('Unsupported framework');
+};

package/node_modules/serverless-http/lib/provider/aws/clean-up-event.js

@@ -0,0 +1,98 @@
+'use strict';
+
+function removeBasePath(path = '/', basePath) {
+  if (basePath) {
+    const basePathIndex = path.indexOf(basePath);
+
+    if (basePathIndex > -1) {
+      return path.substr(basePathIndex + basePath.length) || '/';
+    }
+  }
+
+  return path;
+}
+
+function isString(value)
+{
+  return (typeof value === 'string' || value instanceof String);
+}
+
+// ELBs will pass spaces as + symbols, and decodeURIComponent doesn't decode + symbols. So we need to convert them into something it can convert
+function specialDecodeURIComponent(value)
+{
+  if(!isString(value))
+  {
+    return value;
+  }
+
+  let decoded;
+  try {
+    decoded = decodeURIComponent(value.replace(/[+]/g, "%20"));
+  } catch (err) {
+    decoded = value.replace(/[+]/g, "%20");
+  }
+
+  return decoded;
+}
+
+function recursiveURLDecode(value) {
+
+  if (isString(value)) {
+    return specialDecodeURIComponent(value);
+  } else if (Array.isArray(value)) {
+
+    const decodedArray = [];
+
+    for (let index in value) {
+      decodedArray.push(recursiveURLDecode(value[index]));
+    }
+
+    return decodedArray;
+
+  } else if (value instanceof Object) {
+
+    const decodedObject = {};
+
+    for (let key of Object.keys(value)) {
+      decodedObject[specialDecodeURIComponent(key)] = recursiveURLDecode(value[key]);
+    }
+
+    return decodedObject;
+  }
+
+  return value;
+}
+
+module.exports = function cleanupEvent(evt, options) {
+  const event = evt || {};
+
+  event.requestContext = event.requestContext || {};
+  event.body = event.body || '';
+  event.headers = event.headers || {};
+
+  // Events coming from AWS Elastic Load Balancers do not automatically urldecode query parameters (unlike API Gateway). So we need to check for that and automatically decode them
+  // to normalize the request between the two.
+  if ('elb' in event.requestContext) {
+
+    if (event.multiValueQueryStringParameters) {
+      event.multiValueQueryStringParameters = recursiveURLDecode(event.multiValueQueryStringParameters);
+    }
+
+    if (event.queryStringParameters) {
+      event.queryStringParameters = recursiveURLDecode(event.queryStringParameters);
+    }
+
+  }
+
+  if (event.version === '2.0') {
+    event.requestContext.authorizer = event.requestContext.authorizer || {};
+    event.requestContext.http.method = event.requestContext.http.method || 'GET';
+    event.rawPath = removeBasePath(event.requestPath || event.rawPath, options.basePath);
+  } else {
+    event.requestContext.identity = event.requestContext.identity || {};
+    event.httpMethod = event.httpMethod || 'GET';
+    event.path = removeBasePath(event.requestPath || event.path, options.basePath);
+  }
+
+  return event;
+};

package/node_modules/serverless-http/lib/provider/aws/create-request.js

@@ -0,0 +1,110 @@
+'use strict';
+
+const URL = require('url');
+
+const Request = require('../../request');
+
+function requestMethod(event) {
+  if (event.version === '2.0') {
+    return event.requestContext.http.method;
+  }
+  return event.httpMethod;
+}
+
+function requestRemoteAddress(event) {
+  if (event.version === '2.0') {
+    return event.requestContext.http.sourceIp;
+  }
+  return event.requestContext.identity.sourceIp;
+}
+
+function requestHeaders(event) {
+  const initialHeader =
+    event.version === '2.0' && Array.isArray(event.cookies)
+      ? { cookie: event.cookies.join('; ') }
+      : {};
+
+  if (event.multiValueHeaders) {
+    Object.keys(event.multiValueHeaders).reduce((headers, key) => {
+      headers[key.toLowerCase()] = event.multiValueHeaders[key].join(', ');
+      return headers;
+    }, initialHeader);
+  }
+
+  return Object.keys(event.headers).reduce((headers, key) => {
+    headers[key.toLowerCase()] = event.headers[key];
+    return headers;
+  }, initialHeader);
+}
+
+function requestBody(event) {
+  const type = typeof event.body;
+
+  if (Buffer.isBuffer(event.body)) {
+    return event.body;
+  } else if (type === 'string') {
+    return Buffer.from(event.body, event.isBase64Encoded ? 'base64' : 'utf8');
+  } else if (type === 'object') {
+    return Buffer.from(JSON.stringify(event.body));
+  }
+
+  throw new Error(`Unexpected event.body type: ${typeof event.body}`);
+}
+
+function requestUrl(event) {
+  if (event.version === '2.0') {
+    return URL.format({
+      pathname: event.rawPath,
+      search: event.rawQueryString,
+    });
+  }
+  // Normalize all query params into a single query string.
+  const query = event.multiValueQueryStringParameters || {};
+  if (event.queryStringParameters) {
+    Object.keys(event.queryStringParameters).forEach((key) => {
+      if (Array.isArray(query[key])) {
+        if (!query[key].includes(event.queryStringParameters[key])) {
+          query[key].push(event.queryStringParameters[key]);
+        }
+      } else {
+        query[key] = [event.queryStringParameters[key]];
+      }
+    });
+  }
+  return URL.format({
+    pathname: event.path,
+    query: query,
+  });
+}
+
+module.exports = (event, context, options) => {
+  const method = requestMethod(event);
+  const remoteAddress = requestRemoteAddress(event);
+  const headers = requestHeaders(event);
+  const body = requestBody(event);
+  const url = requestUrl(event);
+
+  if (typeof options.requestId === 'string' && options.requestId.length > 0) {
+    const header = options.requestId.toLowerCase();
+    const requestId = headers[header] || event.requestContext.requestId;
+    if (requestId) {
+      headers[header] = requestId;
+    }
+  }
+
+  const req = new Request({
+    method,
+    headers,
+    body,
+    remoteAddress,
+    url,
+  });
+
+  req.requestContext = event.requestContext;
+  req.apiGateway = {
+    event,
+    context,
+  };
+
+  return req;
+};

package/node_modules/serverless-http/lib/provider/aws/format-response.js

@@ -0,0 +1,45 @@
+'use strict';
+
+const isBinary = require('./is-binary');
+const Response = require('../../response');
+const sanitizeHeaders = require('./sanitize-headers');
+
+module.exports = (event, response, options) => {
+  const { statusCode } = response;
+  const {headers, multiValueHeaders } = sanitizeHeaders(Response.headers(response));
+
+  let cookies = [];
+
+  if (multiValueHeaders['set-cookie']) {
+    cookies = multiValueHeaders['set-cookie'];
+  }
+
+  const isBase64Encoded = isBinary(headers, options);
+  const encoding = isBase64Encoded ? 'base64' : 'utf8';
+  let body = Response.body(response).toString(encoding);
+
+  if (headers['transfer-encoding'] === 'chunked' || response.chunkedEncoding) {
+    const raw = Response.body(response).toString().split('\r\n');
+    const parsed = [];
+    for (let i = 0; i < raw.length; i +=2) {
+      const size = parseInt(raw[i], 16);
+      const value = raw[i + 1];
+      if (value) {
+        parsed.push(value.substring(0, size));
+      }
+    }
+    body = parsed.join('')
+  }
+
+  let formattedResponse = { statusCode, headers, isBase64Encoded, body };
+
+  if (event.version === '2.0' && cookies.length) {
+    formattedResponse['cookies'] = cookies;
+  }
+
+  if ((!event.version || event.version === '1.0') && Object.keys(multiValueHeaders).length) {
+    formattedResponse['multiValueHeaders'] = multiValueHeaders;
+  }
+
+  return formattedResponse;
+};

package/node_modules/serverless-http/lib/provider/aws/index.js

@@ -0,0 +1,15 @@
+const cleanUpEvent = require('./clean-up-event');
+
+const createRequest = require('./create-request');
+const formatResponse = require('./format-response');
+
+module.exports = options => {
+  return getResponse => async (event_, context = {}) => {
+    const event = cleanUpEvent(event_, options);
+
+    const request = createRequest(event, context, options);
+    const response = await getResponse(request, event, context);
+
+    return formatResponse(event, response, options);
+  };
+};