silgi 0.0.14 → 0.1.0-beta.2

package/dist/plugins/openapi.mjs

@@ -1,204 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { generateSchema } from '@anatine/zod-openapi';
-import consola from 'consola';
-import { a as defineSilgiPlugin } from '../shared/silgi.BMCYk2cR.mjs';
-import 'hookable';
-import 'node:buffer';
-import 'node:fs';
-import 'unctx';
-
-function parseMethodName(methodName) {
-  const [method, ...pathParts] = methodName.split(":");
-  const path = pathParts.join(":");
-  return !path || !isHttpMethod(method) ? { method: "post", path: methodName } : { method, path };
-}
-function isHttpMethod(method) {
-  return ["get", "post", "put", "delete", "patch"].includes(method.toLowerCase());
-}
-const createOpenAPIPlugin = defineSilgiPlugin({
-  name: "openapi",
-  async setup(config, initSilgi) {
-    const document = {
-      openapi: "3.1",
-      info: {
-        title: config.title || "API Documentation",
-        version: config.version || "1.0.0",
-        description: config.description || ""
-      },
-      servers: config.servers || [{
-        url: "/",
-        description: "Default Server",
-        // Required by ServerObject
-        variables: {}
-        // Required by ServerObject
-      }],
-      paths: {},
-      components: {
-        schemas: {
-          Success: {
-            description: "Success response",
-            type: "object",
-            required: ["success"],
-            properties: {
-              success: { type: "boolean", enum: [true] },
-              data: { type: "object" }
-            }
-          },
-          Error: {
-            description: "Error response",
-            type: "object",
-            required: ["success", "error"],
-            properties: {
-              success: { type: "boolean", enum: [false] },
-              error: {
-                type: "object",
-                properties: {
-                  code: { type: "string" },
-                  message: { type: "string" }
-                }
-              }
-            }
-          }
-        }
-      }
-    };
-    const paths = {};
-    const services = initSilgi.getAllServices();
-    for (const [scopeName, scope] of Object.entries(services)) {
-      for (const serviceName of scope.services) {
-        const service = initSilgi.getService(scopeName, serviceName);
-        for (const [methodName, handler] of service.handlers.entries()) {
-          let schema = handler.options?.plugins?.openapi?.schema;
-          const sharedZod = initSilgi.silgi.options.shared[scopeName]?.zod;
-          if (!schema && sharedZod) {
-            try {
-              schema = createSchemaFromZod(sharedZod[serviceName][methodName]);
-            } catch {
-              if (!schema?.input || !schema?.output) {
-                consola.withTag("silgi:openapi").info("Please add schema for", scopeName, serviceName, methodName);
-              }
-            }
-          }
-          const { method, path } = parseMethodName(String(methodName));
-          const route = `/${scopeName}/${serviceName}/${path}`;
-          const operation = {
-            tags: [scopeName, serviceName],
-            summary: String(methodName).split(":")[1] || String(methodName),
-            description: String(`Handle copy: defineService().scope('${scopeName}').service('${serviceName}').methods({ '${String(methodName)}': { ... } })`),
-            parameters: (() => {
-              switch (method) {
-                case "get":
-                  if (!schema?.input)
-                    return [];
-                  return Object.entries(schema.input.properties || {}).map(([paramName, paramSchema]) => ({
-                    in: "query",
-                    name: paramName,
-                    required: schema.input?.required?.includes(paramName) || false,
-                    schema: paramSchema,
-                    description: paramSchema.description || undefined,
-                    $ref: paramSchema.$ref || undefined
-                  }));
-                case "delete":
-                  return [{
-                    in: "path",
-                    name: "id",
-                    required: true,
-                    schema: { type: "string" }
-                  }];
-                case "put":
-                case "patch":
-                  return [{
-                    in: "path",
-                    name: "id",
-                    required: true,
-                    schema: { type: "string" }
-                  }];
-                default:
-                  return [];
-              }
-            })(),
-            ...method !== "get" && method !== "delete" ? {
-              requestBody: {
-                required: true,
-                content: {
-                  "application/json": {
-                    schema: schema?.input || { type: "object" }
-                  }
-                }
-              }
-            } : {},
-            responses: {
-              200: {
-                description: "Successful operation",
-                content: {
-                  "application/json": {
-                    schema: {
-                      type: "object",
-                      required: ["success"],
-                      properties: {
-                        success: { type: "boolean", enum: [true] },
-                        data: schema?.output || { type: "object" }
-                      }
-                    }
-                  }
-                }
-              },
-              400: {
-                description: "Operation failed",
-                content: {
-                  "application/json": {
-                    schema: { $ref: "#/components/schemas/Error" }
-                  }
-                }
-              }
-            }
-          };
-          paths[route] = {
-            ...paths[route],
-            [method]: operation
-          };
-        }
-      }
-    }
-    document.paths = paths;
-    initSilgi.setEvent("openapi", document);
-    if (config.writeToFile) {
-      try {
-        const silgiDir = join(process.cwd(), ".silgi");
-        await mkdir(silgiDir, { recursive: true });
-        const outputJSON = join(silgiDir, "openapi.json");
-        await writeFile(outputJSON, JSON.stringify(document, null, 2), "utf-8");
-      } catch (error) {
-        initSilgi.silgi.logger.error("Failed to generate OpenAPI documentation:", error);
-        throw error;
-      }
-    }
-  }
-});
-function createSchema(schema) {
-  return {
-    input: {
-      type: "object",
-      ...schema.input
-    },
-    output: {
-      type: "object",
-      ...schema.output
-    }
-  };
-}
-function createSchemaFromZod(schema) {
-  return {
-    input: schema.input ? generateSchema(schema.input) : { type: "object" },
-    output: schema.output ? generateSchema(schema.output) : { type: "object" }
-  };
-}
-function getOpenAPIDocument(initSilgi) {
-  return initSilgi.getEvent("openapi:document");
-}
-function getOpenAPIPath(initSilgi) {
-  return initSilgi.getEvent("openapi:path");
-}
-
-export { createOpenAPIPlugin, createSchema, createSchemaFromZod, getOpenAPIDocument, getOpenAPIPath };

package/dist/plugins/scalar.d.mts

@@ -1,14 +0,0 @@
-import { P as PergelPlugin, D as DefaultContext, a as DefaultInterface } from '../shared/silgi.D5qK9QOm.mjs';
-import 'consola';
-import 'h3';
-import 'zod';
-import 'hookable';
-
-interface SilgiPluginConfig {
-    writeToFile?: boolean;
-    theme?: 'alternate' | 'default' | 'moon' | 'purple' | 'solarized' | 'bluePlanet' | 'saturn' | 'kepler' | 'mars' | 'deepSpace' | 'none';
-    outputPath?: string;
-}
-declare const createScalarPlugin: (options?: SilgiPluginConfig | undefined) => PergelPlugin<DefaultContext, DefaultInterface, SilgiPluginConfig>;
-
-export { type SilgiPluginConfig, createScalarPlugin };

package/dist/plugins/scalar.d.ts

@@ -1,14 +0,0 @@
-import { P as PergelPlugin, D as DefaultContext, a as DefaultInterface } from '../shared/silgi.D5qK9QOm.js';
-import 'consola';
-import 'h3';
-import 'zod';
-import 'hookable';
-
-interface SilgiPluginConfig {
-    writeToFile?: boolean;
-    theme?: 'alternate' | 'default' | 'moon' | 'purple' | 'solarized' | 'bluePlanet' | 'saturn' | 'kepler' | 'mars' | 'deepSpace' | 'none';
-    outputPath?: string;
-}
-declare const createScalarPlugin: (options?: SilgiPluginConfig | undefined) => PergelPlugin<DefaultContext, DefaultInterface, SilgiPluginConfig>;
-
-export { type SilgiPluginConfig, createScalarPlugin };

package/dist/plugins/scalar.mjs

@@ -1,66 +0,0 @@
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { defineEventHandler } from 'h3';
-import { a as defineSilgiPlugin } from '../shared/silgi.BMCYk2cR.mjs';
-import 'consola';
-import 'hookable';
-import 'node:buffer';
-import 'node:fs';
-import 'unctx';
-
-function generateHTML(openapi, config) {
-  return `<!doctype html>
-<html>
-  <head>
-    <title>${openapi.info.title || "API Documentation"}</title>
-    <meta charset="utf-8" />
-    <meta name="viewport" content="width=device-width, initial-scale=1" />
-  </head>
-  <body>
-    <script id="api-reference" type="application/json">
-      ${JSON.stringify(openapi, null, 2)}
-    <\/script>
-
-    <script>
-      var configuration = {
-        theme: '${config.theme || "deepSpace"}'
-      }
-      document.getElementById('api-reference').dataset.configuration = JSON.stringify(configuration)
-    <\/script>
-
-    <script src="https://cdn.jsdelivr.net/npm/@scalar/api-reference"><\/script>
-  </body>
-</html>`;
-}
-const createScalarPlugin = defineSilgiPlugin({
-  name: "scalar",
-  dependencies: ["openapi"],
-  async setup(config, initSilgi) {
-    const openapi = initSilgi.getEvent("openapi");
-    if (!openapi)
-      throw new Error("OpenAPI document not found. Make sure openapi plugin is initialized before scalar");
-    const scalarHandler = defineEventHandler(async (_event) => {
-      return generateHTML(openapi, config);
-    });
-    const routePath = "/api/_silgi/scalar";
-    initSilgi.silgi.hook("h3:app:setup", (router) => {
-      router.use(routePath, scalarHandler);
-    });
-    if (!config.writeToFile)
-      return;
-    try {
-      const silgiDir = join(process.cwd(), ".silgi");
-      await mkdir(silgiDir, { recursive: true });
-      const outputPath = config.outputPath || "docs";
-      const docsDir = join(silgiDir, outputPath);
-      await mkdir(docsDir, { recursive: true });
-      const htmlPath = join(docsDir, "index.html");
-      await writeFile(htmlPath, generateHTML(openapi, config), "utf-8");
-    } catch (error) {
-      initSilgi.silgi.logger.error("Failed to generate Scalar documentation:", error);
-      throw error;
-    }
-  }
-});
-
-export { createScalarPlugin };