@btst/stack 1.5.2 → 1.7.0

package/dist/packages/better-stack/src/plugins/open-api/api/generator.cjs

@@ -0,0 +1,300 @@
+'use strict';
+
+const z = require('zod');
+
+function _interopNamespaceCompat(e) {
+	if (e && typeof e === 'object' && 'default' in e) return e;
+	const n = Object.create(null);
+	if (e) {
+		for (const k in e) {
+			n[k] = e[k];
+		}
+	}
+	n.default = e;
+	return n;
+}
+
+const z__namespace = /*#__PURE__*/_interopNamespaceCompat(z);
+
+function toOpenApiPath(path) {
+  return path.split("/").map((part) => part.startsWith(":") ? `{${part.slice(1)}}` : part).join("/");
+}
+function getTypeFromZodType(zodType) {
+  if (zodType instanceof z__namespace.ZodString) return "string";
+  if (zodType instanceof z__namespace.ZodNumber) return "number";
+  if (zodType instanceof z__namespace.ZodBoolean) return "boolean";
+  if (zodType instanceof z__namespace.ZodArray) return "array";
+  if (zodType instanceof z__namespace.ZodObject) return "object";
+  const type = zodType.type;
+  if (type === "string") return "string";
+  if (type === "number") return "number";
+  if (type === "boolean") return "boolean";
+  if (type === "array") return "array";
+  if (type === "object") return "object";
+  return "string";
+}
+function processZodType(zodType) {
+  if (zodType instanceof z__namespace.ZodOptional) {
+    const innerType = zodType._def?.innerType || zodType.unwrap?.();
+    if (innerType) {
+      return processZodType(innerType);
+    }
+  }
+  if (zodType instanceof z__namespace.ZodNullable) {
+    const innerType = zodType._def?.innerType || zodType.unwrap?.();
+    if (innerType) {
+      const innerSchema = processZodType(innerType);
+      return {
+        ...innerSchema,
+        nullable: true
+      };
+    }
+  }
+  if (zodType instanceof z__namespace.ZodDefault) {
+    const innerType = zodType._def?.innerType;
+    const defaultValue = zodType._def?.defaultValue?.();
+    if (innerType) {
+      const innerSchema = processZodType(innerType);
+      if (defaultValue !== void 0) {
+        return {
+          ...innerSchema,
+          default: defaultValue
+        };
+      }
+      return innerSchema;
+    }
+  }
+  if (zodType instanceof z__namespace.ZodObject) {
+    const shape = zodType.shape || zodType._def?.shape?.();
+    if (shape) {
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        if (value instanceof z__namespace.ZodType) {
+          properties[key] = processZodType(value);
+          if (!(value instanceof z__namespace.ZodOptional)) {
+            required.push(key);
+          }
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+  }
+  if (zodType instanceof z__namespace.ZodArray) {
+    const elementType = zodType._def?.type || zodType.element;
+    return {
+      type: "array",
+      items: elementType ? processZodType(elementType) : { type: "string" }
+    };
+  }
+  if (zodType instanceof z__namespace.ZodEnum) {
+    const values = zodType._def?.values || zodType.options;
+    return {
+      type: "string",
+      enum: values
+    };
+  }
+  if (zodType instanceof z__namespace.ZodLiteral) {
+    const value = zodType._def?.value || zodType.value;
+    let type;
+    if (value === null) {
+      type = "null";
+    } else if (value === void 0) {
+      return { nullable: true };
+    } else {
+      type = typeof value;
+    }
+    return {
+      type,
+      const: value
+    };
+  }
+  if (zodType instanceof z__namespace.ZodUnion) {
+    const options = zodType._def?.options || zodType.options;
+    if (options && Array.isArray(options)) {
+      return {
+        oneOf: options.map((opt) => processZodType(opt))
+      };
+    }
+  }
+  if (zodType._def?.coerce) {
+    const innerType = zodType._def?.innerType;
+    if (innerType) {
+      return processZodType(innerType);
+    }
+  }
+  return {
+    type: getTypeFromZodType(zodType)
+  };
+}
+function getParameters(options) {
+  const parameters = [];
+  if (options.query instanceof z__namespace.ZodObject) {
+    const shape = options.query.shape || options.query._def?.shape?.();
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (value instanceof z__namespace.ZodType) {
+          parameters.push({
+            name: key,
+            in: "query",
+            required: !(value instanceof z__namespace.ZodOptional),
+            schema: processZodType(value)
+          });
+        }
+      }
+    }
+  }
+  if (options.params instanceof z__namespace.ZodObject) {
+    const shape = options.params.shape || options.params._def?.shape?.();
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (value instanceof z__namespace.ZodType) {
+          parameters.push({
+            name: key,
+            in: "path",
+            required: true,
+            schema: processZodType(value)
+          });
+        }
+      }
+    }
+  }
+  return parameters;
+}
+function getRequestBody(options) {
+  if (!options.body) return void 0;
+  if (options.body instanceof z__namespace.ZodType) {
+    const schema = processZodType(options.body);
+    const isOptional = options.body instanceof z__namespace.ZodOptional;
+    return {
+      required: !isOptional,
+      content: {
+        "application/json": {
+          schema
+        }
+      }
+    };
+  }
+  return void 0;
+}
+function createErrorSchema() {
+  return {
+    type: "object",
+    properties: {
+      message: { type: "string" }
+    },
+    required: ["message"]
+  };
+}
+function getErrorResponses() {
+  return {
+    "400": {
+      description: "Bad Request",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "401": {
+      description: "Unauthorized",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "403": {
+      description: "Forbidden",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "404": {
+      description: "Not Found",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "500": {
+      description: "Internal Server Error",
+      content: { "application/json": { schema: createErrorSchema() } }
+    }
+  };
+}
+function generateOpenAPISchema(context, options) {
+  const paths = {};
+  const tags = [];
+  for (const [pluginKey, plugin] of Object.entries(context.plugins)) {
+    if (pluginKey === "openApi" || plugin.name === "open-api") {
+      continue;
+    }
+    const pluginRoutes = plugin.routes(context.adapter, context);
+    const tagName = pluginKey.charAt(0).toUpperCase() + pluginKey.slice(1);
+    tags.push({
+      name: tagName,
+      description: `${tagName} plugin endpoints`
+    });
+    for (const [routeKey, endpoint] of Object.entries(pluginRoutes)) {
+      const ep = endpoint;
+      const path = ep.path;
+      const endpointOptions = ep.options || {};
+      const method = (endpointOptions.method || "GET").toLowerCase();
+      if (!path) continue;
+      const openApiPath = toOpenApiPath(path);
+      if (!paths[openApiPath]) {
+        paths[openApiPath] = {};
+      }
+      const operation = {
+        tags: [tagName],
+        operationId: `${pluginKey}_${routeKey}`,
+        summary: endpointOptions.metadata?.openapi?.summary,
+        description: endpointOptions.metadata?.openapi?.description,
+        parameters: getParameters(endpointOptions),
+        responses: {
+          "200": {
+            description: "Successful response",
+            content: {
+              "application/json": {
+                schema: { type: "object" }
+              }
+            }
+          },
+          ...getErrorResponses()
+        }
+      };
+      if (["post", "put", "patch"].includes(method)) {
+        const requestBody = getRequestBody(endpointOptions);
+        if (requestBody) {
+          operation.requestBody = requestBody;
+        }
+      }
+      paths[openApiPath][method] = operation;
+    }
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: options?.title || "Better Stack API",
+      description: options?.description || "API Reference for your Better Stack application",
+      version: options?.version || "1.0.0"
+    },
+    servers: [
+      {
+        url: context.basePath,
+        description: "API Server"
+      }
+    ],
+    tags,
+    paths,
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: "Bearer token authentication"
+        },
+        cookieAuth: {
+          type: "apiKey",
+          in: "cookie",
+          name: "session",
+          description: "Session cookie authentication"
+        }
+      }
+    }
+  };
+}
+
+exports.generateOpenAPISchema = generateOpenAPISchema;

package/dist/packages/better-stack/src/plugins/open-api/api/generator.mjs

@@ -0,0 +1,284 @@
+import * as z from 'zod';
+
+function toOpenApiPath(path) {
+  return path.split("/").map((part) => part.startsWith(":") ? `{${part.slice(1)}}` : part).join("/");
+}
+function getTypeFromZodType(zodType) {
+  if (zodType instanceof z.ZodString) return "string";
+  if (zodType instanceof z.ZodNumber) return "number";
+  if (zodType instanceof z.ZodBoolean) return "boolean";
+  if (zodType instanceof z.ZodArray) return "array";
+  if (zodType instanceof z.ZodObject) return "object";
+  const type = zodType.type;
+  if (type === "string") return "string";
+  if (type === "number") return "number";
+  if (type === "boolean") return "boolean";
+  if (type === "array") return "array";
+  if (type === "object") return "object";
+  return "string";
+}
+function processZodType(zodType) {
+  if (zodType instanceof z.ZodOptional) {
+    const innerType = zodType._def?.innerType || zodType.unwrap?.();
+    if (innerType) {
+      return processZodType(innerType);
+    }
+  }
+  if (zodType instanceof z.ZodNullable) {
+    const innerType = zodType._def?.innerType || zodType.unwrap?.();
+    if (innerType) {
+      const innerSchema = processZodType(innerType);
+      return {
+        ...innerSchema,
+        nullable: true
+      };
+    }
+  }
+  if (zodType instanceof z.ZodDefault) {
+    const innerType = zodType._def?.innerType;
+    const defaultValue = zodType._def?.defaultValue?.();
+    if (innerType) {
+      const innerSchema = processZodType(innerType);
+      if (defaultValue !== void 0) {
+        return {
+          ...innerSchema,
+          default: defaultValue
+        };
+      }
+      return innerSchema;
+    }
+  }
+  if (zodType instanceof z.ZodObject) {
+    const shape = zodType.shape || zodType._def?.shape?.();
+    if (shape) {
+      const properties = {};
+      const required = [];
+      for (const [key, value] of Object.entries(shape)) {
+        if (value instanceof z.ZodType) {
+          properties[key] = processZodType(value);
+          if (!(value instanceof z.ZodOptional)) {
+            required.push(key);
+          }
+        }
+      }
+      return {
+        type: "object",
+        properties,
+        ...required.length > 0 ? { required } : {}
+      };
+    }
+  }
+  if (zodType instanceof z.ZodArray) {
+    const elementType = zodType._def?.type || zodType.element;
+    return {
+      type: "array",
+      items: elementType ? processZodType(elementType) : { type: "string" }
+    };
+  }
+  if (zodType instanceof z.ZodEnum) {
+    const values = zodType._def?.values || zodType.options;
+    return {
+      type: "string",
+      enum: values
+    };
+  }
+  if (zodType instanceof z.ZodLiteral) {
+    const value = zodType._def?.value || zodType.value;
+    let type;
+    if (value === null) {
+      type = "null";
+    } else if (value === void 0) {
+      return { nullable: true };
+    } else {
+      type = typeof value;
+    }
+    return {
+      type,
+      const: value
+    };
+  }
+  if (zodType instanceof z.ZodUnion) {
+    const options = zodType._def?.options || zodType.options;
+    if (options && Array.isArray(options)) {
+      return {
+        oneOf: options.map((opt) => processZodType(opt))
+      };
+    }
+  }
+  if (zodType._def?.coerce) {
+    const innerType = zodType._def?.innerType;
+    if (innerType) {
+      return processZodType(innerType);
+    }
+  }
+  return {
+    type: getTypeFromZodType(zodType)
+  };
+}
+function getParameters(options) {
+  const parameters = [];
+  if (options.query instanceof z.ZodObject) {
+    const shape = options.query.shape || options.query._def?.shape?.();
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (value instanceof z.ZodType) {
+          parameters.push({
+            name: key,
+            in: "query",
+            required: !(value instanceof z.ZodOptional),
+            schema: processZodType(value)
+          });
+        }
+      }
+    }
+  }
+  if (options.params instanceof z.ZodObject) {
+    const shape = options.params.shape || options.params._def?.shape?.();
+    if (shape) {
+      for (const [key, value] of Object.entries(shape)) {
+        if (value instanceof z.ZodType) {
+          parameters.push({
+            name: key,
+            in: "path",
+            required: true,
+            schema: processZodType(value)
+          });
+        }
+      }
+    }
+  }
+  return parameters;
+}
+function getRequestBody(options) {
+  if (!options.body) return void 0;
+  if (options.body instanceof z.ZodType) {
+    const schema = processZodType(options.body);
+    const isOptional = options.body instanceof z.ZodOptional;
+    return {
+      required: !isOptional,
+      content: {
+        "application/json": {
+          schema
+        }
+      }
+    };
+  }
+  return void 0;
+}
+function createErrorSchema() {
+  return {
+    type: "object",
+    properties: {
+      message: { type: "string" }
+    },
+    required: ["message"]
+  };
+}
+function getErrorResponses() {
+  return {
+    "400": {
+      description: "Bad Request",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "401": {
+      description: "Unauthorized",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "403": {
+      description: "Forbidden",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "404": {
+      description: "Not Found",
+      content: { "application/json": { schema: createErrorSchema() } }
+    },
+    "500": {
+      description: "Internal Server Error",
+      content: { "application/json": { schema: createErrorSchema() } }
+    }
+  };
+}
+function generateOpenAPISchema(context, options) {
+  const paths = {};
+  const tags = [];
+  for (const [pluginKey, plugin] of Object.entries(context.plugins)) {
+    if (pluginKey === "openApi" || plugin.name === "open-api") {
+      continue;
+    }
+    const pluginRoutes = plugin.routes(context.adapter, context);
+    const tagName = pluginKey.charAt(0).toUpperCase() + pluginKey.slice(1);
+    tags.push({
+      name: tagName,
+      description: `${tagName} plugin endpoints`
+    });
+    for (const [routeKey, endpoint] of Object.entries(pluginRoutes)) {
+      const ep = endpoint;
+      const path = ep.path;
+      const endpointOptions = ep.options || {};
+      const method = (endpointOptions.method || "GET").toLowerCase();
+      if (!path) continue;
+      const openApiPath = toOpenApiPath(path);
+      if (!paths[openApiPath]) {
+        paths[openApiPath] = {};
+      }
+      const operation = {
+        tags: [tagName],
+        operationId: `${pluginKey}_${routeKey}`,
+        summary: endpointOptions.metadata?.openapi?.summary,
+        description: endpointOptions.metadata?.openapi?.description,
+        parameters: getParameters(endpointOptions),
+        responses: {
+          "200": {
+            description: "Successful response",
+            content: {
+              "application/json": {
+                schema: { type: "object" }
+              }
+            }
+          },
+          ...getErrorResponses()
+        }
+      };
+      if (["post", "put", "patch"].includes(method)) {
+        const requestBody = getRequestBody(endpointOptions);
+        if (requestBody) {
+          operation.requestBody = requestBody;
+        }
+      }
+      paths[openApiPath][method] = operation;
+    }
+  }
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: options?.title || "Better Stack API",
+      description: options?.description || "API Reference for your Better Stack application",
+      version: options?.version || "1.0.0"
+    },
+    servers: [
+      {
+        url: context.basePath,
+        description: "API Server"
+      }
+    ],
+    tags,
+    paths,
+    components: {
+      securitySchemes: {
+        bearerAuth: {
+          type: "http",
+          scheme: "bearer",
+          description: "Bearer token authentication"
+        },
+        cookieAuth: {
+          type: "apiKey",
+          in: "cookie",
+          name: "session",
+          description: "Session cookie authentication"
+        }
+      }
+    }
+  };
+}
+
+export { generateOpenAPISchema };

package/dist/packages/better-stack/src/plugins/open-api/api/plugin.cjs

@@ -0,0 +1,115 @@
+'use strict';
+
+const api = require('@btst/stack/plugins/api');
+const db = require('../db.cjs');
+const generator = require('./generator.cjs');
+const logo = require('../logo.cjs');
+
+function escapeHtml(str) {
+  return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
+}
+function escapeJsonForHtml(json) {
+  return json.replace(/</g, "\\u003c");
+}
+function getScalarHTML(schema, theme = "default", nonce) {
+  const nonceAttr = nonce ? ` nonce="${escapeHtml(nonce)}"` : "";
+  const encodedLogo = encodeURIComponent(logo.logo);
+  const title = schema.info?.title || "API Reference";
+  const description = schema.info?.description || "API Reference";
+  return `<!doctype html>
+<html>
+  <head>
+    <title>${escapeHtml(title)}</title>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+  </head>
+  <body>
+    <script
+      id="api-reference"
+      type="application/json"${nonceAttr}>
+    ${escapeJsonForHtml(JSON.stringify(schema))}
+    <\/script>
+    <script${nonceAttr}>
+      var configuration = {
+        favicon: "data:image/svg+xml;utf8,${encodedLogo}",
+        theme: "${theme}",
+        metaData: {
+          title: ${JSON.stringify(title)},
+          description: ${JSON.stringify(description)},
+        }
+      }
+
+      document.getElementById('api-reference').dataset.configuration =
+        JSON.stringify(configuration)
+    <\/script>
+    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"${nonceAttr}><\/script>
+  </body>
+</html>`;
+}
+const openApiBackendPlugin = (options) => {
+  const referencePath = options?.path ?? "/reference";
+  let storedContext = null;
+  return api.defineBackendPlugin({
+    name: "open-api",
+    dbPlugin: db.openApiSchema,
+    routes: (_adapter, context) => {
+      storedContext = context ?? null;
+      const generateSchema = api.createEndpoint(
+        "/open-api/schema",
+        {
+          method: "GET"
+        },
+        async (ctx) => {
+          if (!storedContext) {
+            throw ctx.error(500, {
+              message: "OpenAPI context not available"
+            });
+          }
+          const schema = generator.generateOpenAPISchema(storedContext, {
+            title: options?.title,
+            description: options?.description,
+            version: options?.version
+          });
+          return schema;
+        }
+      );
+      const reference = api.createEndpoint(
+        referencePath,
+        {
+          method: "GET"
+        },
+        async (ctx) => {
+          if (options?.disableDefaultReference) {
+            throw ctx.error(404, {
+              message: "Reference page is disabled"
+            });
+          }
+          if (!storedContext) {
+            throw ctx.error(500, {
+              message: "OpenAPI context not available"
+            });
+          }
+          const schema = generator.generateOpenAPISchema(storedContext, {
+            title: options?.title,
+            description: options?.description,
+            version: options?.version
+          });
+          return new Response(
+            getScalarHTML(schema, options?.theme, options?.nonce),
+            {
+              headers: {
+                "Content-Type": "text/html; charset=utf-8"
+              }
+            }
+          );
+        }
+      );
+      return {
+        generateSchema,
+        reference
+      };
+    }
+  });
+};
+
+exports.openApiBackendPlugin = openApiBackendPlugin;