silgi 0.0.1 → 0.0.2

package/bin/silgi.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+'use strict'
+import '../cli/index.mjs'

package/dist/chunks/generate.mjs

@@ -0,0 +1,911 @@
+import { loadConfig } from 'c12';
+import { defineCommand } from 'citty';
+import { writeFileSync, promises } from 'node:fs';
+import { dirname, relative, join } from 'node:path';
+import antfu from '@antfu/eslint-config';
+import consola from 'consola';
+import defu from 'defu';
+import { ESLint } from 'eslint';
+import { createJiti } from 'jiti';
+import { resolve } from 'pathe';
+import { camelCase, pascalCase } from 'scule';
+import { parseSync } from '@oxc-parser/wasm';
+import { writeFile } from 'node:fs/promises';
+
+async function generateClientGenTS(storage, outputDir) {
+  const services = Object.keys(storage);
+  let clientGenContent = `
+  `;
+  const imports = [];
+  for (const service of services) {
+    const clientStore = storage[service];
+    let clientStoreContent = `
+    `;
+    if (Array.isArray(clientStore?.graphql?.query) && clientStore.graphql.query.length > 0) {
+      const queryContent = `
+      query: {
+        ${clientStore.graphql.query.map((query) => {
+        imports.push(`import {${query.key}} from '${query.path}'`);
+        return `${query.newKey}: {
+            input: VariablesOf<typeof ${query.key}>
+            output: ResultOf<typeof ${query.key}>
+          }`;
+      }).join("\n")}
+      }
+      `;
+      clientStoreContent += queryContent;
+    }
+    if (Array.isArray(clientStore?.graphql?.mutation) && clientStore.graphql.mutation.length > 0) {
+      const mutationContent = `
+      mutation: {
+        ${clientStore.graphql.mutation.map((mutation) => {
+        imports.push(`import {${mutation.key}} from '${mutation.path}'`);
+        return `${mutation.newKey}: {
+            input: VariablesOf<typeof ${mutation.key}>
+            output: ResultOf<typeof ${mutation.key}>
+          }`;
+      }).join("\n")}
+      }
+      `;
+      clientStoreContent += mutationContent;
+    }
+    if (Array.isArray(clientStore?.zod) && clientStore.zod.length > 0) {
+      const zodContent = `
+      zod: {
+        ${clientStore.zod.map((zod) => {
+        imports.push(`import {${zod.key}} from '${zod.path}'`);
+        return `${zod.newKey}: {
+            input: Zod.infer<typeof ${zod.key}>
+          }`;
+      }).join("\n")}
+      }
+      `;
+      clientStoreContent += zodContent;
+    }
+    clientGenContent += `
+    ${service}: {
+      ${clientStoreContent}
+    }
+    `;
+  }
+  const content = `
+  // This file is generated by Silgi. Do not modify it manually.
+${imports.join("\n")}
+
+  export interface SilgiClientStore {
+    ${clientGenContent}
+  }
+  `;
+  writeFileSync(outputDir, content, "utf-8");
+}
+
+class SchemaParser {
+  parseExports(content, filePath) {
+    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
+    return {
+      exportTS: this.parseTypeExports(ast),
+      exportVariables: this.parseVariableExports(ast)
+    };
+  }
+  parseTypeExports(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter(
+      (i) => i.declaration?.type === "TSInterfaceDeclaration" || i.declaration?.type === "TSTypeAliasDeclaration"
+    ).flatMap((node) => node.declaration?.id.name);
+  }
+  parseVariableExports(ast) {
+    return ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration").flatMap((node) => node.declaration?.declarations.map((decl) => decl.id.name));
+  }
+}
+
+class TypescriptGenerator {
+  storage;
+  outputDir;
+  constructor(storage, outputDir) {
+    this.storage = storage;
+    this.outputDir = outputDir;
+  }
+  async generate() {
+    try {
+      const { scopes, modules } = this.extractScopesAndModules();
+      const processedData = this.processStorageData(scopes, modules);
+      const content = this.generateInterfaceContent(processedData);
+      await this.writeOutputFile(content);
+      consola.success(`Server interface in ${this.outputDir}`);
+    } catch (error) {
+      consola.error("Error generating Silgi interface:", error);
+      throw error;
+    }
+  }
+  extractScopesAndModules() {
+    const scopes = new Set(
+      Object.keys(this.storage.schemaObjects || {}).filter((scope) => scope !== "modules")
+    );
+    const modules = new Set(
+      Object.keys(this.storage.modules || {})
+    );
+    return { scopes, modules };
+  }
+  processStorageData(scopes, modules) {
+    const zodInterfacesImports = [];
+    const importsString = [];
+    const scopeDatas = [];
+    const modulesData = [];
+    for (const scope of scopes) {
+      if (!this.storage.schemaObjects)
+        throw new Error("No schemaObjects found in storage");
+      const scopeData = this.storage.schemaObjects[scope];
+      const processed = this.processScopeData(scope, scopeData, zodInterfacesImports, importsString);
+      scopeDatas.push(processed);
+    }
+    for (const module of modules) {
+      if (this.storage.modules && this.storage.modules[module]) {
+        const moduleData = this.storage.modules[module];
+        const processed = this.processModuleData(module, moduleData, importsString);
+        modulesData.push(processed);
+      }
+    }
+    return { scopeDatas, modulesData, importsString, zodInterfacesImports };
+  }
+  processScopeData(scope, scopeData, zodInterfacesImports, importsString) {
+    const shareds = [];
+    const services = [];
+    const context = [];
+    if (scopeData.zod) {
+      if (scopeData.zod.silgiZodSchema && scopeData.zod.silgiZodSchema?.length > 0) {
+        scopeData.zod.silgiZodSchema?.forEach((schema) => {
+          const name = camelCase(`${scope}_${schema.serviceName}silgiZodSchema`);
+          zodInterfacesImports.push(`import { silgiZodSchema as ${name} } from '${schema.path}'`);
+          shareds.push({
+            type: "const",
+            from: "zod",
+            scope: "true",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+      if (scopeData.zod.SilgiZodSchema && scopeData.zod.SilgiZodSchema?.length > 0) {
+        scopeData.zod.SilgiZodSchema.forEach((schema) => {
+          const name = pascalCase(`${scope}_${schema.serviceName}SilgiZodSchemaType`);
+          zodInterfacesImports.push(`import type { SilgiZodSchema as ${name} } from '${schema.path}'`);
+          shareds.push({
+            type: "type",
+            from: "zod",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+    }
+    if (scopeData.service && scopeData.service.silgiService) {
+      if (scopeData.service.silgiService?.length > 0) {
+        scopeData.service.silgiService.forEach((schema) => {
+          const name = camelCase(`${scope}_${schema.serviceName}silgiService`);
+          importsString.push(`import { silgiService as ${name} } from '${schema.path}'`);
+          services.push({
+            type: "const",
+            from: "service",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+      if (scopeData.service.SilgiService && scopeData.service.SilgiService.length > 0) {
+        scopeData.service.SilgiService.forEach((schema) => {
+          const name = pascalCase(`${scope}_${schema.serviceName}SilgiServiceType`);
+          importsString.push(`import type { SilgiService as ${name} } from '${schema.path}'`);
+          services.push({
+            type: "type",
+            from: "service",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+    }
+    if (scopeData.context) {
+      const processedPaths = /* @__PURE__ */ new Set();
+      if (scopeData.context?.SilgiContext && scopeData.context.SilgiContext.length > 0) {
+        scopeData.context.SilgiContext.forEach((schema) => {
+          if (processedPaths.has(schema.path))
+            return;
+          processedPaths.add(schema.path);
+          const pathSegments = schema.path.split("/");
+          const uniqueIdentifier = pathSegments.slice(-2).filter((segment) => segment !== "index").join("");
+          const name = pascalCase(`${scope}_${uniqueIdentifier}SilgiContextType`);
+          importsString.push(`import type { SilgiContext as ${name} } from '${schema.path}'`);
+          context.push({
+            type: "type",
+            from: "context",
+            key: scope,
+            value: name,
+            path: schema.path
+            // Store path for debugging
+          });
+        });
+      }
+    }
+    if (scopeData.shared) {
+      if (scopeData.shared.silgiGlobalShared && scopeData.shared.silgiGlobalShared?.length > 0) {
+        scopeData.shared.silgiGlobalShared.forEach((schema) => {
+          const name = camelCase(`${scope}_${schema.serviceName}silgiGlobalShared`);
+          importsString.push(`import { silgiGlobalShared as ${name} } from '${schema.path}'`);
+          shareds.push({
+            type: "const",
+            from: "shared",
+            key: schema.serviceName,
+            value: name,
+            global: schema.global
+          });
+        });
+      }
+      if (scopeData.shared.SilgiGlobalShared && scopeData.shared.SilgiGlobalShared?.length > 0) {
+        scopeData.shared.SilgiGlobalShared.forEach((schema) => {
+          const name = pascalCase(`${scope}_${schema.serviceName}SilgiGlobalSharedType`);
+          importsString.push(`import type { SilgiGlobalShared as ${name} } from '${schema.path}'`);
+          shareds.push({
+            type: "type",
+            from: "shared",
+            key: schema.serviceName,
+            value: name,
+            global: schema.global
+          });
+        });
+      }
+    }
+    return {
+      scope,
+      shareds,
+      services,
+      context
+    };
+  }
+  processModuleData(module, moduleData, importsString) {
+    const methodsConfig = [];
+    const context = [];
+    const services = [];
+    const modules = [];
+    const moduleConfig = [];
+    if (moduleData.methodsConfig && moduleData.methodsConfig.silgiMethodConfig) {
+      if (moduleData.methodsConfig.silgiMethodConfig?.length > 0) {
+        moduleData.methodsConfig.silgiMethodConfig.forEach((schema) => {
+          const name = camelCase(`${module}_${schema.serviceName}silgiMethodConfig`);
+          importsString.push(`import { silgiMethodConfig as ${name} } from '${schema.path}'`);
+          methodsConfig.push({
+            type: "const",
+            from: "methodsConfig",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+      if (moduleData.methodsConfig.SilgiMethodConfig && moduleData.methodsConfig.SilgiMethodConfig?.length > 0) {
+        moduleData.methodsConfig.SilgiMethodConfig.forEach((schema) => {
+          const name = pascalCase(`${module}_${schema.serviceName}SilgiMethodConfigType`);
+          importsString.push(`import type { SilgiMethodConfig as ${name} } from '${schema.path}'`);
+          methodsConfig.push({
+            type: "type",
+            from: "methodsConfig",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+    }
+    if (moduleData.context) {
+      const processedPaths = /* @__PURE__ */ new Set();
+      if (moduleData.context.SilgiContext && moduleData.context.SilgiContext?.length > 0) {
+        moduleData.context.SilgiContext.forEach(
+          (schema) => {
+            if (processedPaths.has(schema.path))
+              return;
+            processedPaths.add(schema.path);
+            const pathSegments = schema.path.split("/");
+            const uniqueIdentifier = pathSegments.slice(-2).filter((segment) => segment !== "index").join("");
+            const name = pascalCase(`${module}_${uniqueIdentifier}SilgiContextType`);
+            importsString.push(`import type { SilgiContext as ${name} } from '${schema.path}'`);
+            context.push({
+              type: "type",
+              from: "context",
+              key: module,
+              value: name
+            });
+          }
+        );
+      }
+    }
+    if (moduleData.service) {
+      if (moduleData.service.silgiService && moduleData.service.silgiService?.length > 0) {
+        moduleData.service.silgiService.forEach((schema) => {
+          if (schema.type === "module") {
+            const name = camelCase(`${schema.serviceName}silgiModule`);
+            importsString.push(`import ${name} from '${schema.path}'`);
+            modules.push({
+              type: "module",
+              from: "service",
+              key: schema.serviceName,
+              value: name
+            });
+          } else {
+            const name = camelCase(`${module}_${schema.serviceName}silgiService`);
+            importsString.push(`import { silgiService as ${name} } from '${schema.path}'`);
+            services.push({
+              type: "const",
+              from: "service",
+              key: schema.serviceName,
+              value: name
+            });
+          }
+        });
+      }
+      if (moduleData.service.SilgiService && moduleData.service.SilgiService?.length > 0) {
+        moduleData.service.SilgiService.forEach((schema) => {
+          const name = pascalCase(`${module}_${schema.serviceName}SilgiServiceType`);
+          importsString.push(`import type { SilgiService as ${name} } from '${schema.path}'`);
+          services.push({
+            type: "type",
+            from: "service",
+            key: schema.serviceName,
+            value: name
+          });
+        });
+      }
+    }
+    if (moduleData.moduleConfig) {
+      if (moduleData.moduleConfig.SilgiModuleConfig && moduleData.moduleConfig.SilgiModuleConfig?.length > 0) {
+        moduleData.moduleConfig.SilgiModuleConfig.forEach((schema) => {
+          if (schema.type === "empty") {
+            moduleConfig.push({
+              type: "empty",
+              from: "moduleConfig",
+              key: schema.serviceName,
+              value: schema.serviceName
+            });
+          } else {
+            const name = pascalCase(`${module}_${schema.serviceName}SilgiModuleConfigType`);
+            importsString.push(`import type { SilgiModuleConfig as ${name} } from '${schema.path}'`);
+            moduleConfig.push({
+              type: "type",
+              from: "moduleConfig",
+              key: schema.serviceName,
+              value: name
+            });
+          }
+        });
+      }
+    }
+    return {
+      module,
+      methodsConfig,
+      context,
+      modules,
+      moduleConfig
+    };
+  }
+  generateInterfaceContent({ scopeDatas, modulesData, zodInterfacesImports, importsString }) {
+    return (
+      /* TS */
+      `// This file is auto-generated. Do not edit manually.
+import { createSilgi } from 'silgi'
+import type { OmitSilgiOptions } from 'silgi' 
+import type { InitSilgi, DefaultContext, DefaultInterface } from 'silgi'
+
+${zodInterfacesImports.join("\n")}
+${importsString.join("\n")}
+
+declare module 'silgi' {
+  type SharedGlobalMerge =  ${scopeDatas.some((scope) => scope.context.length > 0) ? `${scopeDatas.filter((scope) => scope.shareds.length > 0).map((scopeData) => {
+        return scopeData.shareds.map((shared) => {
+          if (shared.global) {
+            return shared.value;
+          }
+        }).filter(Boolean).join(" & ");
+      }).filter(Boolean).join(" & ")}` : ""}
+
+  interface DefaultInterface {
+    ${scopeDatas.some((scope) => scope.services.length > 0) ? `scopes: {
+      ${scopeDatas.filter((scope) => scope.services.length > 0).map((scopeData) => {
+        const services = scopeData.services.map((shared) => {
+          if (shared.type === "type") {
+            return `${shared.key}: ${shared.value}`;
+          }
+        }).filter(Boolean).join("\n");
+        return services ? `${scopeData.scope}: {
+            ${services}
+          }` : "";
+      }).filter(Boolean).join("\n")}
+    }` : ""}
+
+    ${scopeDatas.some((scope) => scope.shareds.length > 0) ? `shared: {
+        ${scopeDatas.map((scopeData) => {
+        const zodShared = scopeData.shareds.filter((shared) => shared.from === "zod").map((shared) => {
+          if (shared.type === "type") {
+            return `${shared.key}: ${shared.value}`;
+          }
+        }).filter(Boolean).join("\n");
+        return `
+            ${scopeData.scope}: {
+            ${zodShared ? `zod: {
+                ${zodShared}
+              }
+            }` : ""}`;
+      }).filter(Boolean).join("\n")}
+      } & SharedGlobalMerge` : ""}
+
+    ${modulesData.some((module) => module.methodsConfig.length > 0) ? `plugins: {
+        ${modulesData.map((moduleData) => {
+        const methodsConfig = moduleData.methodsConfig.map((shared) => {
+          if (shared.type === "type") {
+            return `${shared.value}`;
+          }
+        }).filter(Boolean).join("\n");
+        return methodsConfig ? `${moduleData.module}: ${methodsConfig}` : "";
+      }).filter(Boolean).join("\n")}
+      }` : ""}
+}
+  
+  type ExtendDefaultContext = ${[...scopeDatas, ...modulesData].some((item) => item.context?.length > 0) ? [...scopeDatas, ...modulesData].filter((item) => item.context?.length > 0).map((item) => {
+        return item.context.map((shared) => {
+          if (shared.type === "type") {
+            return shared.value;
+          }
+        }).filter(Boolean).join(" & ");
+      }).filter(Boolean).reduce((acc, curr) => acc ? `${acc} & ${curr}` : curr, "") : ""}
+
+  interface DefaultContext extends ExtendDefaultContext {}
+}
+
+export const silgiServices = [
+  ${scopeDatas.flatMap(
+        (scopeData) => scopeData.services.filter((service) => service.type === "const").map((service) => service.value)
+      ).filter(Boolean).join(",\n  ")}
+]
+
+export const silgiShared = {
+  ${scopeDatas.filter((scopeData) => scopeData.shareds.length > 0).map((scopeData) => {
+        const nonZodShared = scopeData.shareds.filter((shared) => shared.from !== "zod").filter((shared) => shared.type === "const").map((shared) => `...${shared.value}`).filter(Boolean).join(",\n    ");
+        const zodShared = scopeData.shareds.filter((shared) => shared.from === "zod").filter((shared) => shared.type === "const").map((shared) => `${shared.key}: ${shared.value}`).filter(Boolean).join(",\n        ");
+        return `
+       ${nonZodShared ? `${nonZodShared},` : ""}
+      ${scopeData.scope}: {
+      ${zodShared ? `zod: {
+        ${zodShared}
+      }` : ""}
+    }`;
+      }).join(",\n  ")}
+}
+
+let _silgi: InitSilgi<DefaultContext, DefaultInterface>
+
+interface SilgiCreateOptions {
+  version: 'v1'
+  silgi?: Omit<OmitSilgiOptions<DefaultContext, DefaultInterface>, 'services' | 'shared' | 'plugins'>
+  ${modulesData.flatMap(
+        (moduleData) => moduleData.moduleConfig.map((module) => {
+          if (module.key === module.value) {
+            return `${module.key}: object`;
+          }
+          return `${module.key}: ${module.value}`;
+        })
+      ).filter(Boolean).join("\n  ")}
+}
+
+export function silgi(options: SilgiCreateOptions) {
+ 
+  if (!_silgi) {
+    _silgi = createSilgi({
+      ...options.silgi,
+      services: silgiServices,
+      shared: silgiShared,
+      plugins: [
+        ${modulesData.flatMap(
+        (moduleData) => moduleData.modules.filter((module) => module.type === "module").map((module) => {
+          const plugin = module.value;
+          return `${plugin}(options.${module.key})`;
+        })
+      ).filter(Boolean).join(",\n        ")}
+      ],
+    })
+    return _silgi
+  }
+  return _silgi
+}
+`
+    );
+  }
+  async writeOutputFile(content) {
+    await writeFile(this.outputDir, content, "utf-8");
+  }
+}
+async function generateSilgiInterface(storage, outputDir) {
+  const generator = new TypescriptGenerator(storage, outputDir);
+  await generator.generate();
+}
+
+function extractNamesFromPath(filePath) {
+  const parts = dirname(filePath).split("/");
+  return {
+    serviceName: parts[parts.length - 1] || "",
+    scopeName: parts[parts.length - 3] || ""
+  };
+}
+function makeRelativePath(from, to) {
+  const relativePath = relative(dirname(from), to);
+  return relativePath.startsWith(".") ? relativePath : `./${relativePath}`;
+}
+function cleanPath(path, removeExtensions = true) {
+  return removeExtensions ? path.replace(/\.ts$/, "") : path;
+}
+
+class SchemaManager {
+  constructor(config) {
+    this.config = config;
+    this.parser = new SchemaParser();
+    this.storage = {
+      schemaObjects: {},
+      path: "",
+      files: [],
+      modules: {}
+    };
+    this.clientSchemas ??= {};
+    this.schemas ??= {};
+  }
+  parser;
+  storage;
+  schemas;
+  modulesSchema;
+  clientSchemas;
+  async serverScan(filePath, scope) {
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      const { exportTS, exportVariables } = this.parser.parseExports(content, filePath);
+      const { serviceName } = extractNamesFromPath(filePath);
+      const scopeName = scope.name;
+      const absoluteFilePath = resolve(this.config.rootDir, filePath);
+      let relativePath = makeRelativePath(this.config._silgi.outputDirTS, absoluteFilePath);
+      relativePath = cleanPath(relativePath, this.config.removeExtensions);
+      this.schemas ??= {};
+      this.schemas[scopeName] ??= {};
+      for (const item of exportTS) {
+        if (item.includes("SilgiContext")) {
+          this.schemas[scopeName].context ??= {};
+          this.schemas[scopeName].context.SilgiContext ??= [];
+          this.schemas[scopeName].context.SilgiContext.push({
+            type: "interface",
+            path: relativePath,
+            serviceName
+          });
+        } else if (item.includes("SilgiZodSchema")) {
+          this.schemas[scopeName].zod ??= {};
+          this.schemas[scopeName].zod.SilgiZodSchema ??= [];
+          this.schemas[scopeName].zod.SilgiZodSchema?.push({
+            type: "interface",
+            path: relativePath,
+            serviceName
+          });
+        } else if (item.includes("SilgiService")) {
+          this.schemas[scopeName].service ??= {};
+          this.schemas[scopeName].service.SilgiService ??= [];
+          this.schemas[scopeName].service.SilgiService.push({
+            type: "interface",
+            path: relativePath,
+            serviceName
+          });
+        } else if (item.includes("SilgiGlobalShared")) {
+          this.schemas[scopeName].shared ??= {};
+          this.schemas[scopeName].shared.SilgiGlobalShared ??= [];
+          this.schemas[scopeName].shared.SilgiGlobalShared.push({
+            type: "interface",
+            global: true,
+            path: relativePath,
+            serviceName
+          });
+        }
+      }
+      for (const item of exportVariables) {
+        if (item.includes("silgiContext")) {
+          this.schemas[scopeName].context ??= {};
+          this.schemas[scopeName].context.SilgiContext ??= [];
+          this.schemas[scopeName].context.SilgiContext.push({
+            type: "const",
+            path: relativePath,
+            serviceName
+          });
+        } else if (item.includes("silgiZodSchema")) {
+          this.schemas[scopeName].zod ??= {};
+          this.schemas[scopeName].zod.silgiZodSchema ??= [];
+          this.schemas[scopeName].zod.silgiZodSchema.push({
+            type: "const",
+            path: relativePath,
+            serviceName
+          });
+        } else if (item.includes("silgiService")) {
+          this.schemas[scopeName].service ??= {};
+          this.schemas[scopeName].service.silgiService ??= [];
+          this.schemas[scopeName].service.silgiService.push({
+            type: "const",
+            path: relativePath,
+            serviceName
+          });
+        } else if (item.includes("silgiGlobalShared")) {
+          this.schemas[scopeName].shared ??= {};
+          this.schemas[scopeName].shared.silgiGlobalShared ??= [];
+          this.schemas[scopeName].shared.silgiGlobalShared.push({
+            type: "const",
+            path: relativePath,
+            serviceName
+          });
+        }
+      }
+      return Object.keys(this.schemas).length > 0;
+    } catch (error) {
+      consola.error(`Error processing file ${filePath}:`, error);
+      return false;
+    }
+  }
+  async clientScan(filePath, _scope) {
+    try {
+      const content = await promises.readFile(filePath, "utf-8");
+      const { exportVariables } = this.parser.parseExports(content, filePath);
+      const { serviceName } = extractNamesFromPath(filePath);
+      const absoluteFilePath = resolve(this.config.rootDir, filePath);
+      let relativePath = makeRelativePath(this.config._silgi.outputDirTS, absoluteFilePath);
+      relativePath = cleanPath(relativePath, this.config.removeExtensions);
+      if (!this.clientSchemas[serviceName]) {
+        this.clientSchemas[serviceName] = {
+          graphql: {
+            mutation: [],
+            query: []
+          },
+          zod: []
+        };
+      }
+      for (const item of exportVariables) {
+        if (typeof item === "string" && item.toLocaleLowerCase().startsWith("zod")) {
+          this.clientSchemas[serviceName].zod.push({
+            type: "const",
+            path: relativePath,
+            serviceName,
+            key: item,
+            newKey: camelCase(item.replace("zod", ""))
+          });
+        }
+        if (typeof item === "string" && item.toLocaleLowerCase().startsWith("mutation")) {
+          this.clientSchemas[serviceName].graphql.mutation.push({
+            type: "const",
+            path: relativePath,
+            serviceName,
+            key: item,
+            newKey: camelCase(item.replace("mutation", ""))
+          });
+        }
+        if (typeof item === "string" && item.toLocaleLowerCase().startsWith("query")) {
+          this.clientSchemas[serviceName].graphql.query.push({
+            type: "const",
+            path: relativePath,
+            serviceName,
+            key: item,
+            newKey: camelCase(item.replace("query", ""))
+          });
+        }
+      }
+      return true;
+    } catch (error) {
+      consola.error(`Error processing file ${filePath}:`, error);
+      return false;
+    }
+  }
+  async scanDirectory(dir, scope) {
+    const scan = async (currentDir) => {
+      const files = await promises.readdir(currentDir);
+      await Promise.all(files.map(async (file) => {
+        const filePath = join(currentDir, file);
+        const stats = await promises.stat(filePath);
+        if (stats.isDirectory()) {
+          await scan(filePath);
+        } else if (file.endsWith(".ts")) {
+          if (scope.type === "client") {
+            await this.clientScan(filePath, scope);
+          } else {
+            const hasSchemas = await this.serverScan(filePath, scope);
+            if (hasSchemas) {
+              this.storage ??= {};
+              this.storage.files ??= [];
+              this.storage.schemaObjects = this.schemas;
+              this.storage.modules = this.modulesSchema;
+              this.storage.files.push(filePath);
+            }
+          }
+        }
+      }));
+    };
+    await scan(dir);
+    return this.storage;
+  }
+  async scanModules(config) {
+    const scan = async (currentDir) => {
+      const files = await promises.readdir(currentDir);
+      const jiti = createJiti(config.rootDir);
+      await Promise.all(files.map(async (file) => {
+        const filePath = join(currentDir, file);
+        const stats = await promises.stat(filePath);
+        const absoluteFilePath = resolve(config.rootDir, filePath);
+        let relativePath = makeRelativePath(config._silgi.outputDirTS, absoluteFilePath);
+        relativePath = cleanPath(relativePath, config.removeExtensions);
+        if (stats.isDirectory()) {
+          await scan(filePath);
+        } else if (file.endsWith(".ts")) {
+          try {
+            const modDefault = await jiti.import(filePath, { default: true });
+            if (typeof modDefault === "function") {
+              const result = modDefault();
+              const name = result.name;
+              this.modulesSchema ??= {};
+              this.modulesSchema[name] ??= {};
+              if (name) {
+                this.modulesSchema[name].service ??= {};
+                this.modulesSchema[name].service.silgiService ??= [];
+                this.modulesSchema[name].service.silgiService.push({
+                  type: "module",
+                  path: relativePath,
+                  serviceName: name
+                });
+                if (result.system) {
+                  if (result.system.context) {
+                    this.modulesSchema[name].context ??= {};
+                    this.modulesSchema[name].context.SilgiContext ??= [];
+                    this.modulesSchema[name].context.SilgiContext.push({
+                      type: "interface",
+                      path: relativePath,
+                      serviceName: "empty"
+                    });
+                  }
+                  if (result.system.shared) {
+                    this.modulesSchema[name].shared ??= {};
+                    this.modulesSchema[name].shared.SilgiGlobalShared ??= [];
+                    this.modulesSchema[name].shared.SilgiGlobalShared.push({
+                      type: "interface",
+                      global: true,
+                      path: relativePath,
+                      serviceName: "empty"
+                    });
+                  }
+                  if (result.system.services) {
+                    this.modulesSchema[name].service ??= {};
+                    this.modulesSchema[name].service.SilgiService ??= [];
+                    this.modulesSchema[name].service.SilgiService.push({
+                      type: "interface",
+                      path: relativePath,
+                      serviceName: "empty"
+                    });
+                  }
+                  if (result.system.methodConfig) {
+                    this.modulesSchema[name].methodsConfig ??= {};
+                    this.modulesSchema[name].methodsConfig.SilgiMethodConfig ??= [];
+                    this.modulesSchema[name].methodsConfig.SilgiMethodConfig.push({
+                      type: "interface",
+                      path: relativePath,
+                      serviceName: "empty",
+                      global: true
+                    });
+                  }
+                  if (result.system.moduleConfig) {
+                    this.modulesSchema[name].moduleConfig ??= {};
+                    this.modulesSchema[name].moduleConfig.SilgiModuleConfig ??= [];
+                    this.modulesSchema[name].moduleConfig.SilgiModuleConfig.push({
+                      type: "interface",
+                      path: relativePath,
+                      serviceName: name,
+                      global: true
+                    });
+                  } else {
+                    this.modulesSchema[name].moduleConfig ??= {};
+                    this.modulesSchema[name].moduleConfig.SilgiModuleConfig ??= [];
+                    this.modulesSchema[name].moduleConfig.SilgiModuleConfig.push({
+                      type: "empty",
+                      path: relativePath,
+                      serviceName: name,
+                      global: true
+                    });
+                  }
+                }
+                consola.log("\u{1F4C1} Scanning module:", this.schemas);
+              }
+            }
+          } catch (error) {
+            consola.error(`Error processing file ${filePath}:`, error);
+          }
+        }
+      }));
+    };
+    if (config.moduleDir) {
+      for (const module of config.moduleDir) {
+        const resolvedPath = resolve(config.rootDir, module);
+        if (module) {
+          await scan(resolvedPath);
+        }
+      }
+    }
+  }
+  async initialize() {
+    const outputFileTS = resolve(this.config.rootDir, this.config.output.server, "silgi.generated.ts");
+    this.config._silgi.outputDirTS = outputFileTS;
+    this.config._silgi.outputDirClientTS = resolve(this.config.rootDir, this.config.output.server, "silgi.generated.ts");
+    await promises.mkdir(this.config.output.server, { recursive: true });
+  }
+  async generateOutput() {
+    const resolvedPath = resolve(this.config.rootDir, this.config.output.server, "silgi.generated.ts");
+    await generateSilgiInterface(this.storage, resolvedPath);
+    if (this.storage?.schemaObjects && this.storage.files) {
+      const schemaCount = Object.keys(this.storage.schemaObjects).length;
+      consola.log(`Found ${schemaCount} schema objects in ${this.storage.files.length} files`);
+    }
+  }
+  async generateClientOutput() {
+    const resolvedPath = resolve(this.config.rootDir, this.config.output.client, "silgi.generated.ts");
+    await generateClientGenTS(this.clientSchemas, resolvedPath);
+    if (this.storage?.schemaObjects && this.storage.files) {
+      const schemaCount = Object.keys(this.storage.schemaObjects).length;
+      consola.log(`Found ${schemaCount} schema objects in ${this.storage.files.length} files`);
+      consola.success(`Generated client schema files in ${resolvedPath}`);
+    }
+  }
+}
+async function generate$1(config) {
+  const mergeConfig = defu(config, {
+    removeExtensions: true,
+    _silgi: {
+      outputDirTS: "",
+      outputDirClientTS: ""
+    }
+  });
+  mergeConfig.rootDir = resolve(mergeConfig.rootDir || config.rootDir || ".");
+  const schemaManager = new SchemaManager(mergeConfig);
+  try {
+    await schemaManager.initialize();
+    await schemaManager.scanModules(mergeConfig);
+    for (const scope of mergeConfig.scopes) {
+      const resolvedPath = resolve(mergeConfig.rootDir, scope.path);
+      consola.log(`\u{1F4C1} Scanning directory: ${resolvedPath}`);
+      await schemaManager.scanDirectory(resolvedPath, scope);
+    }
+    await schemaManager.generateOutput();
+    await schemaManager.generateClientOutput();
+    consola.success("Schema generation completed successfully");
+    const eslint = new ESLint({
+      fix: true,
+      cwd: mergeConfig.rootDir,
+      baseConfig: await antfu({ typescript: true })
+    });
+    const results = await eslint.lintFiles([
+      mergeConfig._silgi.outputDirTS,
+      mergeConfig._silgi.outputDirClientTS
+    ]);
+    await ESLint.outputFixes(results);
+    const formatter = await eslint.loadFormatter("stylish");
+    formatter.format(results);
+  } catch (error) {
+    consola.error("Schema generation failed:", error);
+    process.exit(1);
+  }
+}
+
+const generate = defineCommand({
+  meta: {
+    name: "Silgi Generate",
+    description: "Generate code",
+    version: "0.1.0"
+  },
+  args: {},
+  async run() {
+    const result = await loadConfig({
+      name: "silgi",
+      configFile: "silgi.config",
+      rcFile: ".silgirc"
+    });
+    const silgiConfig = result.config;
+    await generate$1(silgiConfig);
+  }
+});
+
+export { generate as default };

package/dist/chunks/init.mjs

@@ -0,0 +1,21 @@
+import { writeFileSync } from 'node:fs';
+import { defineCommand } from 'citty';
+
+const init = defineCommand({
+  meta: {
+    name: "Silgi Init",
+    description: "Initialize silgi config",
+    version: "0.1.0"
+  },
+  args: {},
+  async run() {
+    const context = `import { defineSilgiConfig } from 'silgi/config'
+
+export default defineSilgiConfig({
+  
+})`;
+    writeFileSync("silgi.config.ts", context);
+  }
+});
+
+export { init as default };

package/dist/cli/config.d.mts

@@ -0,0 +1,19 @@
+interface SilgiConfig {
+    scopes: ScopeConfig[];
+    removeExtensions: boolean;
+    output: {
+        server: string;
+        client: string;
+    };
+    modules?: string[];
+    moduleDir: string[];
+}
+interface ScopeConfig {
+    name: string;
+    path: string;
+    type: 'server' | 'client';
+}
+
+declare function defineSilgiConfig(config: SilgiConfig): SilgiConfig;
+
+export { defineSilgiConfig };

package/dist/cli/config.d.ts

@@ -0,0 +1,19 @@
+interface SilgiConfig {
+    scopes: ScopeConfig[];
+    removeExtensions: boolean;
+    output: {
+        server: string;
+        client: string;
+    };
+    modules?: string[];
+    moduleDir: string[];
+}
+interface ScopeConfig {
+    name: string;
+    path: string;
+    type: 'server' | 'client';
+}
+
+declare function defineSilgiConfig(config: SilgiConfig): SilgiConfig;
+
+export { defineSilgiConfig };

package/dist/cli/config.mjs

@@ -0,0 +1,5 @@
+function defineSilgiConfig(config) {
+  return config;
+}
+
+export { defineSilgiConfig };

package/dist/cli/index.d.mts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+
+export {  }

package/dist/cli/index.mjs

@@ -0,0 +1,103 @@
+import { defineCommand, runMain } from 'citty';
+import consola from 'consola';
+
+const name = "silgi";
+const type = "module";
+const version = "0.0.1";
+const exports = {
+	".": {
+		"import": {
+			types: "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		}
+	},
+	"./plugins/openapi": {
+		types: "./dist/plugins/openapi.d.mts",
+		"import": "./dist/plugins/openapi.mjs"
+	},
+	"./plugins/scalar": {
+		types: "./dist/plugins/scalar.d.mts",
+		"import": "./dist/plugins/scalar.mjs"
+	},
+	"./config": {
+		types: "./dist/cli/config.d.mts",
+		"import": "./dist/cli/config.mjs"
+	}
+};
+const types = "./dist/index.d.ts";
+const bin = {
+	silgi: "bin/silgi.mjs"
+};
+const files = [
+	"dist"
+];
+const scripts = {
+	build: "unbuild",
+	"build:stub": "unbuild --stub",
+	dev: "npx --yes listhen -w --open ./__tests__/h3.ts",
+	"dev:k6": "k6 run ./__tests__/k6.js"
+};
+const dependencies = {
+	"@anatine/zod-openapi": "^2.2.6",
+	"@antfu/eslint-config": "^3.12.1",
+	"@asteasolutions/zod-to-openapi": "^7.3.0",
+	"@oxc-parser/wasm": "^0.44.0",
+	c12: "^2.0.1",
+	citty: "^0.1.6",
+	consola: "^3.3.1",
+	defu: "^6.1.4",
+	eslint: "^9.17.0",
+	h3: "^1.13.0",
+	hookable: "^5.5.3",
+	jiti: "^2.4.2",
+	mlly: "^1.7.3",
+	"openapi3-ts": "^4.4.0",
+	pathe: "^1.1.2",
+	scule: "^1.3.0",
+	unctx: "^2.4.1",
+	zod: "^3.24.1"
+};
+const devDependencies = {
+	silgi: "workspace:*",
+	unbuild: "^3.0.1"
+};
+const resolutions = {
+	silgi: "workspace:*"
+};
+const packageJson = {
+	name: name,
+	type: type,
+	version: version,
+	exports: exports,
+	types: types,
+	bin: bin,
+	files: files,
+	scripts: scripts,
+	dependencies: dependencies,
+	devDependencies: devDependencies,
+	resolutions: resolutions
+};
+
+const main = defineCommand({
+  meta: {
+    name: "Silgi",
+    version: packageJson.version,
+    description: "Silgi CLI"
+  },
+  args: {
+    version: {
+      alias: "v",
+      description: "Show version"
+    }
+  },
+  subCommands: {
+    generate: () => import('../chunks/generate.mjs').then((m) => m.default),
+    init: () => import('../chunks/init.mjs').then((m) => m.default)
+  },
+  run({ args }) {
+    consola.info("Silgi CLI , --help for more info");
+    if (args.version)
+      console.warn("Silgi version:", packageJson.version);
+  }
+});
+runMain(main);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "silgi",
   "type": "module",
-  "version": "0.0.1",
+  "version": "0.0.2",
   "exports": {
     ".": {
       "import": {
@@ -16,9 +16,16 @@
     "./plugins/scalar": {
       "types": "./dist/plugins/scalar.d.mts",
       "import": "./dist/plugins/scalar.mjs"
+    },
+    "./config": {
+      "types": "./dist/cli/config.d.mts",
+      "import": "./dist/cli/config.mjs"
     }
   },
   "types": "./dist/index.d.ts",
+  "bin": {
+    "silgi": "bin/silgi.mjs"
+  },
   "files": [
     "dist"
   ],
@@ -26,20 +33,25 @@
     "@anatine/zod-openapi": "^2.2.6",
     "@antfu/eslint-config": "^3.12.1",
     "@asteasolutions/zod-to-openapi": "^7.3.0",
+    "@oxc-parser/wasm": "^0.44.0",
+    "c12": "^2.0.1",
+    "citty": "^0.1.6",
     "consola": "^3.3.1",
+    "defu": "^6.1.4",
     "eslint": "^9.17.0",
     "h3": "^1.13.0",
     "hookable": "^5.5.3",
     "jiti": "^2.4.2",
     "mlly": "^1.7.3",
     "openapi3-ts": "^4.4.0",
+    "pathe": "^1.1.2",
     "scule": "^1.3.0",
     "unctx": "^2.4.1",
     "zod": "^3.24.1"
   },
   "devDependencies": {
     "unbuild": "^3.0.1",
-    "silgi": "0.0.1"
+    "silgi": "0.0.2"
   },
   "resolutions": {
     "silgi": "workspace:*"