@btst/stack 1.6.0 → 1.8.0

package/dist/api/index.cjs

@@ -11,8 +11,14 @@ function betterStack(config) {
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
     betterDbSchema = betterDbSchema.use(plugin.dbPlugin);
   }
+  const adapterInstance = adapter(betterDbSchema);
+  const context = {
+    plugins,
+    basePath,
+    adapter: adapterInstance
+  };
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
-    const pluginRoutes = plugin.routes(adapter(betterDbSchema));
+    const pluginRoutes = plugin.routes(adapterInstance, context);
     for (const [routeKey, endpoint] of Object.entries(pluginRoutes)) {
       const compositeKey = `${pluginKey}_${routeKey}`;
       allRoutes[compositeKey] = endpoint;

package/dist/api/index.d.cts

@@ -1,5 +1,5 @@
-import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.cjs';
-export { B as BackendPlugin } from '../shared/stack.ByOugz9d.cjs';
+import { g as PrefixedPluginRoutes, h as BackendLibConfig, i as BackendLib } from '../shared/stack.u9iYV6vt.cjs';
+export { B as BackendPlugin, a as BetterStackContext } from '../shared/stack.u9iYV6vt.cjs';
 export { toNodeHandler } from 'better-call/node';
 import '@btst/yar';
 import '@btst/db';

package/dist/api/index.d.mts

@@ -1,5 +1,5 @@
-import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.mjs';
-export { B as BackendPlugin } from '../shared/stack.ByOugz9d.mjs';
+import { g as PrefixedPluginRoutes, h as BackendLibConfig, i as BackendLib } from '../shared/stack.u9iYV6vt.mjs';
+export { B as BackendPlugin, a as BetterStackContext } from '../shared/stack.u9iYV6vt.mjs';
 export { toNodeHandler } from 'better-call/node';
 import '@btst/yar';
 import '@btst/db';

package/dist/api/index.d.ts

@@ -1,5 +1,5 @@
-import { d as PrefixedPluginRoutes, e as BackendLibConfig, f as BackendLib } from '../shared/stack.ByOugz9d.js';
-export { B as BackendPlugin } from '../shared/stack.ByOugz9d.js';
+import { g as PrefixedPluginRoutes, h as BackendLibConfig, i as BackendLib } from '../shared/stack.u9iYV6vt.js';
+export { B as BackendPlugin, a as BetterStackContext } from '../shared/stack.u9iYV6vt.js';
 export { toNodeHandler } from 'better-call/node';
 import '@btst/yar';
 import '@btst/db';

package/dist/api/index.mjs

@@ -9,8 +9,14 @@ function betterStack(config) {
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
     betterDbSchema = betterDbSchema.use(plugin.dbPlugin);
   }
+  const adapterInstance = adapter(betterDbSchema);
+  const context = {
+    plugins,
+    basePath,
+    adapter: adapterInstance
+  };
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
-    const pluginRoutes = plugin.routes(adapter(betterDbSchema));
+    const pluginRoutes = plugin.routes(adapterInstance, context);
     for (const [routeKey, endpoint] of Object.entries(pluginRoutes)) {
       const compositeKey = `${pluginKey}_${routeKey}`;
       allRoutes[compositeKey] = endpoint;

package/dist/client/index.cjs

@@ -6,10 +6,14 @@ const metaUtils = require('../packages/better-stack/src/client/meta-utils.cjs');
 const pathUtils = require('../packages/better-stack/src/client/path-utils.cjs');
 
 function createStackClient(config) {
-  const { plugins } = config;
+  const { plugins, basePath } = config;
   const allRoutes = {};
+  const clientStackContext = {
+    plugins,
+    basePath
+  };
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
-    const pluginRoutes = plugin.routes();
+    const pluginRoutes = plugin.routes(clientStackContext);
     Object.assign(allRoutes, pluginRoutes);
   }
   const router = yar.createRouter(allRoutes);

package/dist/client/index.d.cts

@@ -1,4 +1,5 @@
-import { S as Sitemap, C as ClientPlugin, a as PluginRoutes, b as ClientLibConfig, c as ClientLib } from '../shared/stack.ByOugz9d.cjs';
+import { c as Sitemap, C as ClientPlugin, d as PluginRoutes, e as ClientLibConfig, f as ClientLib } from '../shared/stack.u9iYV6vt.cjs';
+export { b as ClientStackContext } from '../shared/stack.u9iYV6vt.cjs';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/client/index.d.mts

@@ -1,4 +1,5 @@
-import { S as Sitemap, C as ClientPlugin, a as PluginRoutes, b as ClientLibConfig, c as ClientLib } from '../shared/stack.ByOugz9d.mjs';
+import { c as Sitemap, C as ClientPlugin, d as PluginRoutes, e as ClientLibConfig, f as ClientLib } from '../shared/stack.u9iYV6vt.mjs';
+export { b as ClientStackContext } from '../shared/stack.u9iYV6vt.mjs';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/client/index.d.ts

@@ -1,4 +1,5 @@
-import { S as Sitemap, C as ClientPlugin, a as PluginRoutes, b as ClientLibConfig, c as ClientLib } from '../shared/stack.ByOugz9d.js';
+import { c as Sitemap, C as ClientPlugin, d as PluginRoutes, e as ClientLibConfig, f as ClientLib } from '../shared/stack.u9iYV6vt.js';
+export { b as ClientStackContext } from '../shared/stack.u9iYV6vt.js';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/client/index.mjs

@@ -4,10 +4,14 @@ export { metaElementsToObject } from '../packages/better-stack/src/client/meta-u
 export { normalizePath } from '../packages/better-stack/src/client/path-utils.mjs';
 
 function createStackClient(config) {
-  const { plugins } = config;
+  const { plugins, basePath } = config;
   const allRoutes = {};
+  const clientStackContext = {
+    plugins,
+    basePath
+  };
   for (const [pluginKey, plugin] of Object.entries(plugins)) {
-    const pluginRoutes = plugin.routes();
+    const pluginRoutes = plugin.routes(clientStackContext);
     Object.assign(allRoutes, pluginRoutes);
   }
   const router = createRouter(allRoutes);

package/dist/index.d.cts

@@ -1,6 +1,6 @@
 export { betterStack } from './api/index.cjs';
 export { toNodeHandler } from 'better-call/node';
-export { f as BackendLib, e as BackendLibConfig, B as BackendPlugin } from './shared/stack.ByOugz9d.cjs';
+export { i as BackendLib, h as BackendLibConfig, B as BackendPlugin, a as BetterStackContext } from './shared/stack.u9iYV6vt.cjs';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/index.d.mts

@@ -1,6 +1,6 @@
 export { betterStack } from './api/index.mjs';
 export { toNodeHandler } from 'better-call/node';
-export { f as BackendLib, e as BackendLibConfig, B as BackendPlugin } from './shared/stack.ByOugz9d.mjs';
+export { i as BackendLib, h as BackendLibConfig, B as BackendPlugin, a as BetterStackContext } from './shared/stack.u9iYV6vt.mjs';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

package/dist/index.d.ts

@@ -1,6 +1,6 @@
 export { betterStack } from './api/index.js';
 export { toNodeHandler } from 'better-call/node';
-export { f as BackendLib, e as BackendLibConfig, B as BackendPlugin } from './shared/stack.ByOugz9d.js';
+export { i as BackendLib, h as BackendLibConfig, B as BackendPlugin, a as BetterStackContext } from './shared/stack.u9iYV6vt.js';
 import '@btst/yar';
 import '@btst/db';
 import 'better-call';

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;