@farm.js/core 0.1.60 → 0.1.61

package/dist/chunk-OLGQZRW6.mjs

@@ -1,700 +0,0 @@
-import {
-  APITypeGenerator
-} from "./chunk-HPP2II4Z.mjs";
-import {
-  __require
-} from "./chunk-Y6FXYEAI.mjs";
-
-// src/openapi/generator.ts
-var allowedType = /* @__PURE__ */ new Set(["string", "number", "boolean", "array", "object"]);
-var zodTypeNameKinds = {
-  ZodArray: "array",
-  ZodBoolean: "boolean",
-  ZodDefault: "default",
-  ZodEnum: "enum",
-  ZodLiteral: "literal",
-  ZodNullable: "nullable",
-  ZodNumber: "number",
-  ZodObject: "object",
-  ZodOptional: "optional",
-  ZodRecord: "record",
-  ZodString: "string",
-  ZodTuple: "tuple",
-  ZodUnion: "union"
-};
-function getZodKind(schema) {
-  if (!schema || typeof schema !== "object") return void 0;
-  const definition = schema._def;
-  if (!definition || typeof definition !== "object") return void 0;
-  if (typeof definition.type === "string") return definition.type;
-  return typeof definition.typeName === "string" ? zodTypeNameKinds[definition.typeName] : void 0;
-}
-function getZodObjectShape(schema) {
-  if (getZodKind(schema) !== "object") return void 0;
-  const candidate = schema.shape ?? schema._def?.shape;
-  const shape = typeof candidate === "function" ? candidate() : candidate;
-  return shape && typeof shape === "object" ? shape : void 0;
-}
-function isStandardSchema(schema) {
-  return !!schema && typeof schema === "object" && typeof schema["~standard"]?.validate === "function";
-}
-function openAPITypeForLiteralValues(values) {
-  if (values.length === 0) return "string";
-  const jsType = typeof values[0];
-  if (!values.every((value) => typeof value === jsType)) return "string";
-  switch (jsType) {
-    case "number":
-      return "number";
-    case "bigint":
-      return "number";
-    case "boolean":
-      return "boolean";
-    default:
-      return "string";
-  }
-}
-var OpenAPIGenerator = class {
-  constructor(appDir, config, context = {}) {
-    this.appDir = appDir;
-    this.config = config;
-    this.context = context;
-  }
-  /**
-   * Get type from Zod type
-   */
-  getTypeFromZodType(zodType) {
-    const tag = getZodKind(zodType);
-    return typeof tag === "string" && allowedType.has(tag) ? tag : "string";
-  }
-  /**
-   * Whether a schema field must be supplied by the caller. A field with a
-   * default is supplied by the server when omitted, so — like an explicitly
-   * optional field — it is not required. Only ZodOptional was excluded before,
-   * which documented every `.default()` field as required.
-   */
-  isRequiredField(value) {
-    const kind = getZodKind(value);
-    return kind !== "optional" && kind !== "default";
-  }
-  /**
-   * Process Zod type to OpenAPI schema
-   */
-  processZodType(zodType) {
-    const kind = getZodKind(zodType);
-    const definition = zodType?._def;
-    if (!kind) {
-      return isStandardSchema(zodType) ? { description: "Schema metadata is unavailable for this Standard Schema validator." } : { description: "Schema metadata is unavailable." };
-    }
-    if (kind === "optional") {
-      return this.processZodType(definition.innerType);
-    }
-    if (kind === "nullable") {
-      const innerType = definition.innerType;
-      const innerSchema = this.processZodType(innerType);
-      return {
-        ...innerSchema,
-        nullable: true
-      };
-    }
-    if (kind === "default") {
-      return this.processZodType(definition.innerType);
-    }
-    if (kind === "object") {
-      const shape = getZodObjectShape(zodType);
-      if (shape) {
-        const properties = {};
-        const required = [];
-        Object.entries(shape).forEach(([key, value]) => {
-          if (getZodKind(value) || isStandardSchema(value)) {
-            properties[key] = this.processZodType(value);
-            if (this.isRequiredField(value)) {
-              required.push(key);
-            }
-          }
-        });
-        return {
-          type: "object",
-          properties,
-          ...required.length > 0 ? { required } : {},
-          description: zodType.description
-        };
-      }
-    }
-    if (kind === "array") {
-      return {
-        type: "array",
-        items: this.processZodType(
-          definition.element ?? (typeof definition.type === "object" ? definition.type : void 0)
-        ),
-        description: zodType.description
-      };
-    }
-    if (kind === "enum") {
-      const options = zodType.options ?? (definition.entries ? Object.values(definition.entries) : definition.values);
-      return {
-        type: "string",
-        enum: options,
-        description: zodType.description
-      };
-    }
-    if (kind === "literal") {
-      const values = definition.values ?? (Object.prototype.hasOwnProperty.call(definition, "value") ? [definition.value] : []);
-      return {
-        type: openAPITypeForLiteralValues(values),
-        ...values.length > 0 ? { enum: [...values] } : {},
-        description: zodType.description
-      };
-    }
-    if (kind === "union") {
-      const options = definition.options ?? [];
-      return {
-        oneOf: options.map((option) => this.processZodType(option)),
-        description: zodType.description
-      };
-    }
-    if (kind === "record") {
-      return {
-        type: "object",
-        additionalProperties: this.processZodType(definition.valueType),
-        description: zodType.description
-      };
-    }
-    if (kind === "tuple") {
-      const items = definition.items ?? [];
-      const rest = definition.rest;
-      const itemSchemas = [...items, ...rest ? [rest] : []].map(
-        (item) => this.processZodType(item)
-      );
-      const tupleSchema = {
-        type: "array",
-        items: itemSchemas.length === 1 ? itemSchemas[0] : { oneOf: itemSchemas },
-        description: zodType.description
-      };
-      if (!rest) {
-        tupleSchema.minItems = items.length;
-        tupleSchema.maxItems = items.length;
-      }
-      return tupleSchema;
-    }
-    const baseSchema = {
-      type: this.getTypeFromZodType(zodType),
-      description: zodType.description
-    };
-    const constraints = [
-      ["minLength", zodType.minLength],
-      ["maxLength", zodType.maxLength],
-      ["minimum", zodType.minValue],
-      ["maximum", zodType.maxValue]
-    ];
-    for (const check of definition.checks ?? []) {
-      if (check?.kind === "min") {
-        constraints.push([kind === "string" ? "minLength" : "minimum", check.value]);
-      } else if (check?.kind === "max") {
-        constraints.push([kind === "string" ? "maxLength" : "maximum", check.value]);
-      }
-    }
-    for (const [key, value] of constraints) {
-      if (Number.isFinite(value) && Math.abs(value) !== Number.MAX_SAFE_INTEGER) {
-        baseSchema[key] = value;
-      }
-    }
-    return baseSchema;
-  }
-  getResponses(metadata) {
-    const responses = Object.entries(metadata.responses ?? {}).filter(
-      (entry) => entry[1] !== void 0
-    );
-    if (responses.length === 0) {
-      return {
-        default: {
-          description: "Response metadata is unavailable."
-        }
-      };
-    }
-    return Object.fromEntries(
-      responses.map(([status, response]) => [status, this.getResponse(response)])
-    );
-  }
-  getResponse(response) {
-    if (response.body === "empty") {
-      return {
-        description: response.description ?? "Empty response"
-      };
-    }
-    if (response.body === "binary") {
-      return {
-        description: response.description ?? "Binary response",
-        content: {
-          [response.contentType ?? "application/octet-stream"]: {
-            schema: { type: "string", format: "binary" }
-          }
-        }
-      };
-    }
-    const contentType = response.body === "json" ? response.contentType ?? "application/json" : response.contentType;
-    return {
-      description: response.description ?? (response.body === "json" ? "JSON response" : "Streaming response"),
-      content: {
-        [contentType]: response.schema ? { schema: response.schema } : {}
-      }
-    };
-  }
-  /**
-   * Generate OpenAPI spec from API routes
-   */
-  async generateSpec(routes, requestOrigin) {
-    var _a, _b;
-    const spec = {
-      openapi: "3.0.3",
-      info: {
-        title: this.config.title || "API Documentation",
-        description: this.config.description || "Auto-generated API documentation",
-        version: this.config.version || "1.0.0",
-        ...this.config.contact && { contact: this.config.contact },
-        ...this.config.license && { license: this.config.license }
-      },
-      servers: this.resolveServers(requestOrigin),
-      paths: {},
-      components: {
-        schemas: {},
-        securitySchemes: {
-          bearerAuth: {
-            type: "http",
-            scheme: "bearer",
-            description: "Bearer token authentication"
-          },
-          apiKeyCookie: {
-            type: "apiKey",
-            in: "cookie",
-            name: "session",
-            description: "API Key authentication via cookie"
-          }
-        }
-      }
-    };
-    const routeGroups = /* @__PURE__ */ new Map();
-    for (const route of routes) {
-      const key = route.path;
-      if (!routeGroups.has(key)) {
-        routeGroups.set(key, []);
-      }
-      routeGroups.get(key).push(route);
-    }
-    for (const [path, routeList] of routeGroups) {
-      for (const variant of this.getOpenAPIPathVariants(path)) {
-        (_a = spec.paths)[_b = variant.path] ?? (_a[_b] = {});
-        for (const route of routeList) {
-          for (const method of route.methods) {
-            if (variant.operationIdSuffix === "base") {
-              const existingOperation = method === "QUERY" ? spec.paths[variant.path]["x-oai-additionalOperations"]?.QUERY : spec.paths[variant.path][method.toLowerCase()];
-              if (existingOperation) continue;
-            }
-            const operation = await this.generateOperation(
-              route,
-              method,
-              variant.path,
-              variant.operationIdSuffix
-            );
-            if (method === "QUERY") {
-              const additionalOperations = spec.paths[variant.path]["x-oai-additionalOperations"] ?? {};
-              additionalOperations.QUERY = operation;
-              spec.paths[variant.path]["x-oai-additionalOperations"] = additionalOperations;
-            } else {
-              spec.paths[variant.path][method.toLowerCase()] = operation;
-            }
-          }
-        }
-      }
-    }
-    return spec;
-  }
-  /**
-   * Resolve server entries in decreasing order of authority: explicit OpenAPI
-   * servers, Farm's public API base, the current development request origin,
-   * and finally a mode-appropriate default.
-   */
-  resolveServers(requestOrigin) {
-    if (this.config.servers !== void 0) return this.config.servers;
-    const apiBaseURL = this.context.apiBaseURL || "/api";
-    if (/^https?:\/\//i.test(apiBaseURL)) {
-      return [{ url: apiBaseURL, description: "Farm API server" }];
-    }
-    if (requestOrigin) {
-      return [
-        {
-          url: new URL(apiBaseURL, `${requestOrigin.replace(/\/$/, "")}/`).toString(),
-          description: "Current development server"
-        }
-      ];
-    }
-    if (this.context.mode === "production") {
-      return [{ url: apiBaseURL, description: "Same-origin API server" }];
-    }
-    return [
-      {
-        url: new URL(apiBaseURL, "http://localhost:3000/").toString(),
-        description: "Development server"
-      }
-    ];
-  }
-  /**
-   * Convert a Farm.js API path to OpenAPI path format.
-   *
-   * Strips the `/api` prefix and rewrites dynamic segments to OpenAPI's
-   * `{name}` templating: `[id]` -> `{id}`, `[...slug]` -> `{slug}`, and
-   * `[[...slug]]` -> `{slug}`. Leaving the bracket form produces a path key that
-   * is invalid OpenAPI, which breaks "try it" and any generated client.
-   */
-  convertToOpenAPIPath(path) {
-    const converted = path.replace(/^\/api/, "").replace(/\[\[\.\.\.([^\]]+)\]\]/g, "{$1}").replace(/\[\.\.\.([^\]]+)\]/g, "{$1}").replace(/\[([^\]]+)\]/g, "{$1}");
-    return converted || "/";
-  }
-  /**
-   * OpenAPI does not permit optional path parameters. An optional catch-all
-   * therefore becomes two concrete paths: the empty base path and the
-   * parameterized catch-all path.
-   */
-  getOpenAPIPathVariants(path) {
-    if (!/\/\[\[\.\.\.[^\]]+\]\]/.test(path)) {
-      return [{ path: this.convertToOpenAPIPath(path) }];
-    }
-    const basePath = path.replace(/\/\[\[\.\.\.[^\]]+\]\]/g, "") || "/api";
-    return [
-      { path: this.convertToOpenAPIPath(basePath), operationIdSuffix: "base" },
-      { path: this.convertToOpenAPIPath(path) }
-    ];
-  }
-  /**
-   * Path parameters implied by a Farm.js API path's dynamic segments. Every
-   * path parameter is `required: true` per the OpenAPI spec (a path parameter
-   * cannot be optional), including catch-all segments.
-   */
-  getPathParameters(openAPIPath) {
-    return [...openAPIPath.matchAll(/\{([^}]+)\}/g)].map((match) => ({
-      name: match[1],
-      in: "path",
-      required: true,
-      schema: { type: "string" }
-    }));
-  }
-  /**
-   * Extract request body schema from endpoint
-   */
-  async getRequestBody(route, method) {
-    if (!["QUERY", "POST", "PUT", "PATCH", "DELETE"].includes(method)) {
-      return void 0;
-    }
-    try {
-      const modulePath = route.filePath;
-      const routeModule = await import(
-        /* @vite-ignore */
-        modulePath
-      );
-      const handler = routeModule[method];
-      const bodySchema = handler?.__types?.body ?? handler?._type?.body;
-      if (bodySchema) {
-        return {
-          required: this.isRequiredField(bodySchema),
-          content: {
-            "application/json": {
-              schema: this.processZodType(bodySchema)
-            }
-          }
-        };
-      }
-      return void 0;
-    } catch (error) {
-      console.warn(`Could not extract schema from ${route.filePath}:`, error);
-      return {
-        required: false,
-        content: {
-          "application/json": {
-            schema: {
-              type: "object",
-              description: "Request body"
-            }
-          }
-        }
-      };
-    }
-  }
-  /**
-   * Extract query parameters from endpoint
-   */
-  async getParameters(route, method) {
-    const parameters = [];
-    try {
-      const modulePath = route.filePath;
-      const routeModule = await import(
-        /* @vite-ignore */
-        modulePath
-      );
-      const handler = routeModule[method];
-      const querySchema = handler?.__types?.query ?? handler?._type?.query;
-      const shape = getZodObjectShape(querySchema);
-      if (shape) {
-        Object.entries(shape).forEach(([key, value]) => {
-          if (getZodKind(value) || isStandardSchema(value)) {
-            parameters.push({
-              name: key,
-              in: "query",
-              required: this.isRequiredField(value),
-              schema: this.processZodType(value)
-            });
-          }
-        });
-      }
-    } catch (error) {
-      console.warn(`Could not extract query params from ${route.filePath}:`, error);
-    }
-    return parameters;
-  }
-  /**
-   * Generate OpenAPI operation from route info
-   */
-  async generateOperation(route, method, openAPIPath = this.convertToOpenAPIPath(route.path), operationIdSuffix) {
-    const metadata = await this.getEndpointOpenAPIMetadata(route, method);
-    const security = this.getSecurityRequirements(
-      metadata.security ?? this.config.security ?? "public"
-    );
-    const operation = {
-      summary: this.generateSummary(route.path, method),
-      description: this.generateDescription(route.path, method),
-      operationId: this.generateOperationId(route.path, method, operationIdSuffix),
-      tags: this.generateTags(route.path),
-      ...security ? { security } : {},
-      responses: this.getResponses(metadata)
-    };
-    const parameters = [
-      ...this.getPathParameters(openAPIPath),
-      ...await this.getParameters(route, method)
-    ];
-    if (parameters.length > 0) {
-      operation.parameters = parameters;
-    }
-    if (["QUERY", "POST", "PUT", "PATCH", "DELETE"].includes(method)) {
-      const requestBody = await this.getRequestBody(route, method);
-      if (requestBody) {
-        operation.requestBody = requestBody;
-      }
-    }
-    return operation;
-  }
-  async getEndpointOpenAPIMetadata(route, method) {
-    try {
-      const routeModule = await import(
-        /* @vite-ignore */
-        route.filePath
-      );
-      return routeModule[method]?.__openapi ?? {};
-    } catch {
-      return {};
-    }
-  }
-  getSecurityRequirements(mode) {
-    if (mode === "public") return void 0;
-    if (mode === "bearer") return [{ bearerAuth: [] }];
-    if (mode === "cookie") return [{ apiKeyCookie: [] }];
-    return [{ bearerAuth: [] }, { apiKeyCookie: [] }];
-  }
-  /**
-   * Generate operation summary
-   */
-  generateSummary(path, method) {
-    const cleanPath = path.replace(/^\/api\//, "");
-    const pathParts = cleanPath.split("/");
-    const lastPart = pathParts[pathParts.length - 1];
-    const action = method === "GET" ? "Get" : method === "QUERY" ? "Query" : method === "POST" ? "Create" : method === "PUT" ? "Update" : method === "DELETE" ? "Delete" : method === "PATCH" ? "Update" : method;
-    return `${action} ${lastPart}`;
-  }
-  /**
-   * Generate operation description
-   */
-  generateDescription(path, method) {
-    const cleanPath = path.replace(/^\/api\//, "");
-    return `${method} ${cleanPath} endpoint`;
-  }
-  /**
-   * Generate operation ID
-   */
-  generateOperationId(path, method, suffix) {
-    const cleanPath = path.replace(/^\/api\//, "").replace(/\//g, "_");
-    return `${method.toLowerCase()}_${cleanPath}${suffix ? `_${suffix}` : ""}`;
-  }
-  /**
-   * Generate tags for grouping operations
-   */
-  generateTags(path) {
-    const cleanPath = path.replace(/^\/api\//, "");
-    const pathParts = cleanPath.split("/");
-    if (pathParts.length > 1) {
-      return [pathParts[0]];
-    }
-    return ["default"];
-  }
-  /**
-   * Generate OpenAPI spec file
-   */
-  async generateSpecFile(routes, outputPath) {
-    const spec = await this.generateSpec(routes);
-    const fs = __require("fs");
-    const path = __require("path");
-    const dir = path.dirname(outputPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    fs.writeFileSync(outputPath, JSON.stringify(spec, null, 2));
-  }
-};
-
-// src/openapi/scalar-assets.ts
-var SCALAR_API_REFERENCE_VERSION = "1.38.1";
-var SCALAR_CDN_BASE = `https://cdn.jsdelivr.net/npm/@scalar/api-reference@${SCALAR_API_REFERENCE_VERSION}`;
-var SCALAR_API_REFERENCE_SCRIPT = {
-  url: `${SCALAR_CDN_BASE}/dist/browser/standalone.js`,
-  integrity: "sha384-87uSxO5SeoAG+4aLsnXHJWpb9Gx1biSeaI0O4O5z9OBFe7ZaEJ1LlvVGBo2CkcSO"
-};
-var SCALAR_API_REFERENCE_STYLES = {
-  url: `${SCALAR_CDN_BASE}/dist/style.css`,
-  integrity: "sha384-D1NAbn/NwPaQ5LosRasICtufkVzdUvZZ4+PuXyFYOuR/AzPE0G5BOkXqju29Np+S"
-};
-
-// src/openapi/manager.ts
-function escapeHTML(value) {
-  return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&#39;");
-}
-function renderOpenAPIReferenceHTML(spec, config) {
-  return `
-<!DOCTYPE html>
-<html>
-  <head>
-    <title>${escapeHTML(config.title || "API Documentation")}</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <link rel="icon" href="data:," />
-  </head>
-  <body>
-    <script
-      id="api-reference"
-      data-url="data:application/json;base64,${Buffer.from(JSON.stringify(spec)).toString("base64")}"
-    ></script>
-    <script
-      src="${SCALAR_API_REFERENCE_SCRIPT.url}"
-      integrity="${SCALAR_API_REFERENCE_SCRIPT.integrity}"
-      crossorigin="anonymous"
-    ></script>
-  </body>
-</html>
-    `;
-}
-var OpenAPIManager = class {
-  constructor(appDir, config, context = {}) {
-    this.specCache = null;
-    const appDirs = Array.isArray(appDir) ? [...appDir] : [appDir];
-    this.appDir = appDirs[appDirs.length - 1];
-    this.config = config;
-    this.generator = new OpenAPIGenerator(this.appDir, config, context);
-    this.apiTypeGenerator = new APITypeGenerator(appDirs);
-  }
-  /**
-   * Generate OpenAPI spec from API routes
-   */
-  async generateSpec() {
-    try {
-      const routes = this.apiTypeGenerator.scanAPIRoutes();
-      const spec = await this.generator.generateSpec(routes);
-      this.specCache = spec;
-      return spec;
-    } catch (error) {
-      console.error("Failed to generate OpenAPI spec:", error);
-      return null;
-    }
-  }
-  /**
-   * Get cached spec or generate new one
-   */
-  async getSpec(requestOrigin) {
-    const spec = this.specCache ?? await this.generateSpec();
-    if (!requestOrigin || !spec) return spec;
-    return {
-      ...spec,
-      servers: this.generator.resolveServers(requestOrigin)
-    };
-  }
-  /**
-   * Generate and save OpenAPI spec file
-   */
-  async generateSpecFile() {
-    try {
-      const routes = this.apiTypeGenerator.scanAPIRoutes();
-      const outputPath = `${this.appDir}/lib/openapi.spec.json`;
-      await this.generator.generateSpecFile(routes, outputPath);
-      console.log("\u2705 OpenAPI spec generated at:", outputPath);
-    } catch (error) {
-      console.error("Failed to generate OpenAPI spec file:", error);
-    }
-  }
-  /**
-   * Invalidate cache and regenerate spec
-   */
-  async invalidateCache() {
-    this.specCache = null;
-    await this.generateSpec();
-  }
-  /**
-   * Get the docs route handler
-   */
-  getDocsRouteHandler(requestOrigin) {
-    return async (req, res) => {
-      try {
-        const method = String(req.method || "GET").toUpperCase();
-        if (method !== "GET" && method !== "HEAD") {
-          res.statusCode = 405;
-          res.setHeader("Allow", "GET, HEAD");
-          res.setHeader("Content-Type", "text/plain; charset=utf-8");
-          res.end("Method Not Allowed");
-          return;
-        }
-        const spec = await this.getSpec(requestOrigin);
-        if (!spec) {
-          res.statusCode = 500;
-          res.setHeader("Content-Type", "text/html");
-          res.end(`
-            <html>
-              <body>
-                <h1>Error</h1>
-                <p>Failed to generate OpenAPI specification</p>
-              </body>
-            </html>
-          `);
-          return;
-        }
-        res.statusCode = 200;
-        res.setHeader("Content-Type", "text/html; charset=utf-8");
-        res.setHeader("Cache-Control", "public, max-age=0, must-revalidate");
-        res.setHeader("X-Content-Type-Options", "nosniff");
-        res.end(method === "HEAD" ? void 0 : renderOpenAPIReferenceHTML(spec, this.config));
-      } catch (error) {
-        console.error("Error serving docs route:", error);
-        res.statusCode = 500;
-        res.setHeader("Content-Type", "text/html");
-        res.end(`
-          <html>
-            <body>
-              <h1>Error</h1>
-              <p>Failed to load API documentation</p>
-            </body>
-          </html>
-        `);
-      }
-    };
-  }
-};
-
-export {
-  OpenAPIGenerator,
-  SCALAR_API_REFERENCE_SCRIPT,
-  SCALAR_API_REFERENCE_STYLES,
-  renderOpenAPIReferenceHTML,
-  OpenAPIManager
-};