silgi 0.0.14 → 0.1.0-beta.2

package/dist/chunks/generate.mjs

@@ -1,933 +0,0 @@
-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, DO NOT EDIT!
-/* tslint:disable */
-/* eslint-disable */
-/* prettier-ignore */
-/* silgi - productdevbook.com */
-import type { ResultOf, VariablesOf } from 'gql.tada'
-import type { z as Zod } from 'zod'
-${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: "interface",
-            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: "interface",
-            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: "interface",
-            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: "interface",
-            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) {
-      if (moduleData.methodsConfig.silgiMethodConfig && 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: "interface",
-            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: "interface",
-              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: "interface",
-            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: "interface",
-              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 === "interface") {
-            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 === "interface") {
-            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 === "interface") {
-            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 === "interface") {
-            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.outputDirClientTS, 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);
-        consola.log("\u{1F4C1} Scanning module:", relativePath);
-        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:", Object.keys(this.modulesSchema).length);
-              }
-            }
-          } 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() {
-    if (this.config.output.server) {
-      const outputFileTS = resolve(this.config.rootDir, this.config.output.server, "silgi.generated.ts");
-      this.config._silgi.outputDirTS = outputFileTS;
-      await promises.mkdir(this.config.output.server, { recursive: true });
-    }
-    if (this.config.output.client) {
-      this.config._silgi.outputDirClientTS = resolve(this.config.rootDir, this.config.output.client, "silgi.generated.ts");
-      await promises.mkdir(this.config.output.client, { recursive: true });
-    }
-  }
-  async generateOutput() {
-    if (!this.storage || !this.storage.schemaObjects) {
-      return;
-    }
-    if (this.config.output.server) {
-      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() {
-    if (!this.clientSchemas) {
-      return;
-    }
-    if (this.config.output.client && this.storage.schemaObjects && this.storage.files) {
-      const resolvedPath = resolve(this.config.rootDir, this.config.output.client, "silgi.generated.ts");
-      await generateClientGenTS(this.clientSchemas, resolvedPath);
-      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");
-    try {
-      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 {
-    }
-  } 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 };