silgi 0.0.1

package/README.md

@@ -0,0 +1,2 @@
+```ts
+``

package/dist/index.d.mts

@@ -0,0 +1,37 @@
+import { D as DefaultContext, a as DefaultInterface, E as ExtractScope, S as ServicePluginConfig, b as ServiceMethod, c as ExtractShared, C as CacheScope, d as CacheKeyGenerator, M as MethodPluginConfig, e as ServiceExecutor, O as OmitSilgiOptions, I as InitSilgi, P as PergelPlugin, f as Silgi } from './shared/silgi.BmG_a4Ft.mjs';
+export { h as DefaultHooks, g as InitializedCreateScope, k as SchemaGenerated, i as SilgiDefaultContext, j as SilgiDefaultInterface } from './shared/silgi.BmG_a4Ft.mjs';
+import * as unctx from 'unctx';
+import 'consola';
+import 'h3';
+import 'zod';
+import 'hookable';
+
+declare function defineService<TContext extends DefaultContext = DefaultContext, TInterface extends DefaultInterface = DefaultInterface>(): {
+    scope<TScope extends keyof ExtractScope<TInterface>>(scope: TScope): {
+        service<TService extends keyof ExtractScope<TInterface>[TScope]>(name: TService, config?: ServicePluginConfig<TInterface> | undefined): {
+            methods<TMethods extends { [K in keyof ExtractScope<TInterface>[TScope][TService]]: {
+                handler: (input: ExtractScope<TInterface>[TScope][TService][K] extends ServiceMethod<infer I, any, DefaultInterface> ? I : never, shared: ExtractShared<TInterface>, context: TContext) => Promise<ExtractScope<TInterface>[TScope][TService][K] extends ServiceMethod<any, infer O, DefaultInterface> ? O : never>;
+                options?: {
+                    cache?: {
+                        ttl: number;
+                        scope?: CacheScope;
+                        key?: CacheKeyGenerator<any>;
+                        namespace?: string;
+                    } | undefined;
+                    plugins?: MethodPluginConfig<TInterface> | undefined;
+                } | undefined;
+            }; }>(methodsConfig: TMethods): ServiceExecutor<ExtractScope<TInterface>[TScope][TService], TContext, TInterface>;
+        };
+    };
+};
+declare function createSilgi<TContext extends DefaultContext, TInterface extends DefaultInterface>(options: OmitSilgiOptions<TContext, TInterface>): InitSilgi<TContext, TInterface>;
+declare function defineSilgiPlugin<TPluginConfig, TContext extends DefaultContext = DefaultContext, TInterface extends DefaultInterface = DefaultInterface>(plugin: Omit<PergelPlugin<TContext, TInterface, TPluginConfig>, 'defaults'> & {
+    defaults?: TPluginConfig;
+}): (options?: TPluginConfig) => PergelPlugin<TContext, TInterface, TPluginConfig>;
+
+declare const silgiCtx: unctx.UseContext<InitSilgi<DefaultContext, DefaultInterface>>;
+declare function useShared<TContext extends DefaultContext, TInterface extends DefaultInterface>(): Silgi<TContext, TInterface>["options"]["shared"];
+declare function useSilgi(): InitSilgi<DefaultContext, DefaultInterface>;
+declare function useHook<TContext extends DefaultContext, TInterface extends DefaultInterface>(): Silgi<TContext, TInterface>["hooks"]["hook"];
+
+export { DefaultContext, DefaultInterface, InitSilgi, OmitSilgiOptions, createSilgi, defineService, defineSilgiPlugin, silgiCtx, useHook, useShared, useSilgi };

package/dist/index.d.ts

@@ -0,0 +1,37 @@
+import { D as DefaultContext, a as DefaultInterface, E as ExtractScope, S as ServicePluginConfig, b as ServiceMethod, c as ExtractShared, C as CacheScope, d as CacheKeyGenerator, M as MethodPluginConfig, e as ServiceExecutor, O as OmitSilgiOptions, I as InitSilgi, P as PergelPlugin, f as Silgi } from './shared/silgi.BmG_a4Ft.js';
+export { h as DefaultHooks, g as InitializedCreateScope, k as SchemaGenerated, i as SilgiDefaultContext, j as SilgiDefaultInterface } from './shared/silgi.BmG_a4Ft.js';
+import * as unctx from 'unctx';
+import 'consola';
+import 'h3';
+import 'zod';
+import 'hookable';
+
+declare function defineService<TContext extends DefaultContext = DefaultContext, TInterface extends DefaultInterface = DefaultInterface>(): {
+    scope<TScope extends keyof ExtractScope<TInterface>>(scope: TScope): {
+        service<TService extends keyof ExtractScope<TInterface>[TScope]>(name: TService, config?: ServicePluginConfig<TInterface> | undefined): {
+            methods<TMethods extends { [K in keyof ExtractScope<TInterface>[TScope][TService]]: {
+                handler: (input: ExtractScope<TInterface>[TScope][TService][K] extends ServiceMethod<infer I, any, DefaultInterface> ? I : never, shared: ExtractShared<TInterface>, context: TContext) => Promise<ExtractScope<TInterface>[TScope][TService][K] extends ServiceMethod<any, infer O, DefaultInterface> ? O : never>;
+                options?: {
+                    cache?: {
+                        ttl: number;
+                        scope?: CacheScope;
+                        key?: CacheKeyGenerator<any>;
+                        namespace?: string;
+                    } | undefined;
+                    plugins?: MethodPluginConfig<TInterface> | undefined;
+                } | undefined;
+            }; }>(methodsConfig: TMethods): ServiceExecutor<ExtractScope<TInterface>[TScope][TService], TContext, TInterface>;
+        };
+    };
+};
+declare function createSilgi<TContext extends DefaultContext, TInterface extends DefaultInterface>(options: OmitSilgiOptions<TContext, TInterface>): InitSilgi<TContext, TInterface>;
+declare function defineSilgiPlugin<TPluginConfig, TContext extends DefaultContext = DefaultContext, TInterface extends DefaultInterface = DefaultInterface>(plugin: Omit<PergelPlugin<TContext, TInterface, TPluginConfig>, 'defaults'> & {
+    defaults?: TPluginConfig;
+}): (options?: TPluginConfig) => PergelPlugin<TContext, TInterface, TPluginConfig>;
+
+declare const silgiCtx: unctx.UseContext<InitSilgi<DefaultContext, DefaultInterface>>;
+declare function useShared<TContext extends DefaultContext, TInterface extends DefaultInterface>(): Silgi<TContext, TInterface>["options"]["shared"];
+declare function useSilgi(): InitSilgi<DefaultContext, DefaultInterface>;
+declare function useHook<TContext extends DefaultContext, TInterface extends DefaultInterface>(): Silgi<TContext, TInterface>["hooks"]["hook"];
+
+export { DefaultContext, DefaultInterface, InitSilgi, OmitSilgiOptions, createSilgi, defineService, defineSilgiPlugin, silgiCtx, useHook, useShared, useSilgi };

package/dist/index.mjs

@@ -0,0 +1,7 @@
+export { c as createSilgi, d as defineService, a as defineSilgiPlugin, s as silgiCtx, e as useHook, u as useShared, b as useSilgi } from './shared/silgi.9QqTROsY.mjs';
+import 'consola';
+import 'hookable';
+import 'node:buffer';
+import 'node:fs';
+import 'node:path';
+import 'unctx';

package/dist/plugins/openapi.d.mts

@@ -0,0 +1,138 @@
+import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
+import { SchemaObject, ServerObject, OpenAPIObject } from 'openapi3-ts/oas31';
+import { P as PergelPlugin, D as DefaultContext, a as DefaultInterface, I as InitSilgi } from '../shared/silgi.BmG_a4Ft.mjs';
+import { z } from 'zod';
+import 'consola';
+import 'h3';
+import 'hookable';
+
+interface DefaultSilgiPlugin {
+    openapi?: {
+        schema?: {
+            input?: SchemaObject;
+            output?: SchemaObject;
+        };
+    };
+}
+declare module 'silgi' {
+    interface DefaultInterface {
+        plugins: DefaultSilgiPlugin;
+    }
+}
+interface OpenAPIPluginConfig {
+    title?: string;
+    version?: string;
+    description?: string;
+    servers?: ServerObject[];
+    writeToFile?: boolean;
+    outputPath?: string;
+}
+declare const createOpenAPIPlugin: (options?: OpenAPIPluginConfig | undefined) => PergelPlugin<DefaultContext, DefaultInterface, OpenAPIPluginConfig>;
+declare function createSchema(schema: {
+    input?: Partial<SchemaObject>;
+    output?: Partial<SchemaObject>;
+}): {
+    input: {
+        discriminator?: openapi3_ts_oas31.DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: openapi3_ts_oas31.XmlObject;
+        externalDocs?: openapi3_ts_oas31.ExternalDocumentationObject;
+        example?: any;
+        examples?: any[];
+        deprecated?: boolean;
+        type: string | openapi3_ts_oas31.SchemaObjectType[];
+        format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password" | string;
+        allOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        oneOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        anyOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        not?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        items?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        properties?: {
+            [propertyName: string]: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        };
+        additionalProperties?: SchemaObject | openapi3_ts_oas31.ReferenceObject | boolean;
+        propertyNames?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        description?: string;
+        default?: any;
+        title?: string;
+        multipleOf?: number;
+        maximum?: number;
+        const?: any;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[];
+        enum?: any[];
+        prefixItems?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        contentMediaType?: string;
+        contentEncoding?: string;
+    };
+    output: {
+        discriminator?: openapi3_ts_oas31.DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: openapi3_ts_oas31.XmlObject;
+        externalDocs?: openapi3_ts_oas31.ExternalDocumentationObject;
+        example?: any;
+        examples?: any[];
+        deprecated?: boolean;
+        type: string | openapi3_ts_oas31.SchemaObjectType[];
+        format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password" | string;
+        allOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        oneOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        anyOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        not?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        items?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        properties?: {
+            [propertyName: string]: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        };
+        additionalProperties?: SchemaObject | openapi3_ts_oas31.ReferenceObject | boolean;
+        propertyNames?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        description?: string;
+        default?: any;
+        title?: string;
+        multipleOf?: number;
+        maximum?: number;
+        const?: any;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[];
+        enum?: any[];
+        prefixItems?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        contentMediaType?: string;
+        contentEncoding?: string;
+    };
+};
+declare function createSchemaFromZod(schema: {
+    input?: z.ZodType<any>;
+    output?: z.ZodType<any>;
+}): {
+    input: SchemaObject | {
+        type: string;
+    };
+    output: SchemaObject | {
+        type: string;
+    };
+};
+declare function getOpenAPIDocument(initSilgi: InitSilgi<any, any>): OpenAPIObject;
+declare function getOpenAPIPath(initSilgi: InitSilgi<any, any>): string | undefined;
+
+export { type DefaultSilgiPlugin, type OpenAPIPluginConfig, createOpenAPIPlugin, createSchema, createSchemaFromZod, getOpenAPIDocument, getOpenAPIPath };

package/dist/plugins/openapi.d.ts

@@ -0,0 +1,138 @@
+import * as openapi3_ts_oas31 from 'openapi3-ts/oas31';
+import { SchemaObject, ServerObject, OpenAPIObject } from 'openapi3-ts/oas31';
+import { P as PergelPlugin, D as DefaultContext, a as DefaultInterface, I as InitSilgi } from '../shared/silgi.BmG_a4Ft.js';
+import { z } from 'zod';
+import 'consola';
+import 'h3';
+import 'hookable';
+
+interface DefaultSilgiPlugin {
+    openapi?: {
+        schema?: {
+            input?: SchemaObject;
+            output?: SchemaObject;
+        };
+    };
+}
+declare module 'silgi' {
+    interface DefaultInterface {
+        plugins: DefaultSilgiPlugin;
+    }
+}
+interface OpenAPIPluginConfig {
+    title?: string;
+    version?: string;
+    description?: string;
+    servers?: ServerObject[];
+    writeToFile?: boolean;
+    outputPath?: string;
+}
+declare const createOpenAPIPlugin: (options?: OpenAPIPluginConfig | undefined) => PergelPlugin<DefaultContext, DefaultInterface, OpenAPIPluginConfig>;
+declare function createSchema(schema: {
+    input?: Partial<SchemaObject>;
+    output?: Partial<SchemaObject>;
+}): {
+    input: {
+        discriminator?: openapi3_ts_oas31.DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: openapi3_ts_oas31.XmlObject;
+        externalDocs?: openapi3_ts_oas31.ExternalDocumentationObject;
+        example?: any;
+        examples?: any[];
+        deprecated?: boolean;
+        type: string | openapi3_ts_oas31.SchemaObjectType[];
+        format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password" | string;
+        allOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        oneOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        anyOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        not?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        items?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        properties?: {
+            [propertyName: string]: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        };
+        additionalProperties?: SchemaObject | openapi3_ts_oas31.ReferenceObject | boolean;
+        propertyNames?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        description?: string;
+        default?: any;
+        title?: string;
+        multipleOf?: number;
+        maximum?: number;
+        const?: any;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[];
+        enum?: any[];
+        prefixItems?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        contentMediaType?: string;
+        contentEncoding?: string;
+    };
+    output: {
+        discriminator?: openapi3_ts_oas31.DiscriminatorObject;
+        readOnly?: boolean;
+        writeOnly?: boolean;
+        xml?: openapi3_ts_oas31.XmlObject;
+        externalDocs?: openapi3_ts_oas31.ExternalDocumentationObject;
+        example?: any;
+        examples?: any[];
+        deprecated?: boolean;
+        type: string | openapi3_ts_oas31.SchemaObjectType[];
+        format?: "int32" | "int64" | "float" | "double" | "byte" | "binary" | "date" | "date-time" | "password" | string;
+        allOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        oneOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        anyOf?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        not?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        items?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        properties?: {
+            [propertyName: string]: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        };
+        additionalProperties?: SchemaObject | openapi3_ts_oas31.ReferenceObject | boolean;
+        propertyNames?: SchemaObject | openapi3_ts_oas31.ReferenceObject;
+        description?: string;
+        default?: any;
+        title?: string;
+        multipleOf?: number;
+        maximum?: number;
+        const?: any;
+        exclusiveMaximum?: number;
+        minimum?: number;
+        exclusiveMinimum?: number;
+        maxLength?: number;
+        minLength?: number;
+        pattern?: string;
+        maxItems?: number;
+        minItems?: number;
+        uniqueItems?: boolean;
+        maxProperties?: number;
+        minProperties?: number;
+        required?: string[];
+        enum?: any[];
+        prefixItems?: (SchemaObject | openapi3_ts_oas31.ReferenceObject)[];
+        contentMediaType?: string;
+        contentEncoding?: string;
+    };
+};
+declare function createSchemaFromZod(schema: {
+    input?: z.ZodType<any>;
+    output?: z.ZodType<any>;
+}): {
+    input: SchemaObject | {
+        type: string;
+    };
+    output: SchemaObject | {
+        type: string;
+    };
+};
+declare function getOpenAPIDocument(initSilgi: InitSilgi<any, any>): OpenAPIObject;
+declare function getOpenAPIPath(initSilgi: InitSilgi<any, any>): string | undefined;
+
+export { type DefaultSilgiPlugin, type OpenAPIPluginConfig, createOpenAPIPlugin, createSchema, createSchemaFromZod, getOpenAPIDocument, getOpenAPIPath };

package/dist/plugins/openapi.mjs

@@ -0,0 +1,204 @@
+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.9QqTROsY.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 || void 0,
+                    $ref: paramSchema.$ref || void 0
+                  }));
+                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

@@ -0,0 +1,14 @@
+import { P as PergelPlugin, D as DefaultContext, a as DefaultInterface } from '../shared/silgi.BmG_a4Ft.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

@@ -0,0 +1,14 @@
+import { P as PergelPlugin, D as DefaultContext, a as DefaultInterface } from '../shared/silgi.BmG_a4Ft.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

@@ -0,0 +1,66 @@
+import { mkdir, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { defineEventHandler } from 'h3';
+import { a as defineSilgiPlugin } from '../shared/silgi.9QqTROsY.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 };