silgi 0.24.15 → 0.24.17

package/dist/cli/utils/generateRouterDTS.mjs

@@ -0,0 +1,80 @@
+async function generateRouterDTS(silgi) {
+  const uris = silgi.uris;
+  const subPath = "srn";
+  const groupedPaths = /* @__PURE__ */ new Map();
+  Object.entries(uris || {}).forEach(([key, params]) => {
+    const [service, resource, method, action] = key.split("/");
+    const basePath = params ? `${subPath}/${service}/${resource}/${action}/${params}` : `${subPath}/${service}/${resource}/${action}`;
+    const fullPath = `${subPath}/${service}/${resource}/${action}`;
+    if (!groupedPaths.has(basePath)) {
+      groupedPaths.set(basePath, /* @__PURE__ */ new Map());
+    }
+    groupedPaths.get(basePath)?.set(method.toLowerCase(), fullPath);
+  });
+  const keys = [
+    "  keys: {",
+    Array.from(groupedPaths.entries()).map(([basePath, methods]) => {
+      return `    '/${basePath}': {${Array.from(methods.entries()).map(([method, path]) => `
+      ${method}: '/${path}'`).join(",")}
+    }`;
+    }).join(",\n"),
+    "  }",
+    ""
+  ].join("\n");
+  const groupedRoutes = Object.entries(uris || {}).reduce((acc, [key, _params]) => {
+    const [service, resource, method, action] = key.split("/");
+    const routePath = `${subPath}/${service}/${resource}/${action}`;
+    if (!acc[routePath]) {
+      acc[routePath] = {};
+    }
+    acc[routePath][method] = {
+      input: `ExtractInputFromURI<'${key}'>`,
+      output: `ExtractOutputFromURI<'${key}'>`,
+      queryParams: `ExtractQueryParamsFromURI<'${key}'>`,
+      pathParams: `ExtractPathParamsFromURI<'${key}'>`
+    };
+    return acc;
+  }, {});
+  const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
+    const methodEntries = Object.entries(methods).map(([method, { input, output, queryParams, pathParams }]) => {
+      return `    '${method}': {
+      input: ${input},
+      output: ${output},
+      queryParams: ${queryParams},
+      pathParams: ${pathParams}
+    }`;
+    }).join(",\n");
+    return `  '/${path}': {
+${methodEntries}
+  }`;
+  });
+  const nitro = [
+    "declare module 'nitropack/types' {",
+    "  interface InternalApi extends RouterTypes {}",
+    "}"
+  ];
+  const content = [
+    keys.slice(0, -1),
+    // son satırdaki boş satırı kaldır
+    ...routerTypes
+  ].join(",\n");
+  const context = [
+    "import type { ExtractInputFromURI, ExtractOutputFromURI, ExtractQueryParamsFromURI, ExtractPathParamsFromURI } from 'silgi/types'",
+    "",
+    "export interface RouterTypes {",
+    content,
+    "}",
+    "",
+    "declare module 'silgi/types' {",
+    "  interface SilgiRouterTypes extends RouterTypes {",
+    "  }",
+    "}",
+    "",
+    silgi.options.preset === "h3" || silgi.options.preset === "nitro" ? nitro.join("\n") : "",
+    "",
+    "export {}"
+  ];
+  return context;
+}
+
+export { generateRouterDTS };

package/dist/cli/utils/ignore.mjs

@@ -0,0 +1,46 @@
+import { existsSync, readFileSync } from 'node:fs';
+import ignore from 'ignore';
+import { relative, join } from 'pathe';
+
+function resolveIgnorePatterns(silgi, relativePath) {
+  if (!silgi) {
+    return [];
+  }
+  const ignorePatterns = silgi.options.ignore.flatMap((s) => resolveGroupSyntax(s));
+  const nuxtignoreFile = join(silgi.options.rootDir, ".nuxtignore");
+  if (existsSync(nuxtignoreFile)) {
+    const contents = readFileSync(nuxtignoreFile, "utf-8");
+    ignorePatterns.push(...contents.trim().split(/\r?\n/));
+  }
+  return ignorePatterns;
+}
+function isIgnored(pathname, silgi, _stats) {
+  if (!silgi) {
+    return false;
+  }
+  if (!silgi._ignore) {
+    silgi._ignore = ignore(silgi.options.ignoreOptions);
+    silgi._ignore.add(resolveIgnorePatterns(silgi));
+  }
+  const relativePath = relative(silgi.options.rootDir, pathname);
+  if (relativePath[0] === "." && relativePath[1] === ".") {
+    return false;
+  }
+  return !!(relativePath && silgi._ignore.ignores(relativePath));
+}
+function resolveGroupSyntax(group) {
+  let groups = [group];
+  while (groups.some((group2) => group2.includes("{"))) {
+    groups = groups.flatMap((group2) => {
+      const [head, ...tail] = group2.split("{");
+      if (tail.length) {
+        const [body = "", ...rest] = tail.join("{").split("}");
+        return body.split(",").map((part) => `${head}${part}${rest.join("")}`);
+      }
+      return group2;
+    });
+  }
+  return groups;
+}
+
+export { isIgnored, resolveGroupSyntax, resolveIgnorePatterns };

package/dist/cli/utils/parser.mjs

@@ -0,0 +1,168 @@
+import { writeFileSync } from 'node:fs';
+import { parseSync } from '@oxc-parser/wasm';
+import consola from 'consola';
+import { useSilgiCLI } from 'silgi';
+
+const safeFiles = [
+  "silgi/configs",
+  "silgi",
+  "silgi/rules",
+  "silgi/scan",
+  "silgi/vfs"
+];
+class SchemaParser {
+  options = {
+    debug: false
+  };
+  /**
+   *
+   */
+  constructor(options) {
+    this.options = {
+      ...this.options,
+      ...options
+    };
+  }
+  parseExports(content, filePath) {
+    const ast = parseSync(content, { sourceType: "module", sourceFilename: filePath });
+    if (this.options.debug)
+      writeFileSync(`${filePath}.ast.json`, JSON.stringify(ast.program, null, 2));
+    return {
+      exportVariables: (search, path) => this.parseTypeDeclarations(ast, search, path),
+      parseInterfaceDeclarations: (search, path) => this.parseInterfaceDeclarations(ast, search, path)
+      // parsePlugin: (path: string) => this.parsePlugin(ast, path),
+    };
+  }
+  parseVariableDeclaration(ast, path) {
+    const silgi = useSilgiCLI();
+    if (ast.program.body.length === 0) {
+      if (safeFiles.find((i) => path.includes(i)))
+        return [];
+      silgi.errors.push({
+        type: "Parser",
+        path
+      });
+      consola.warn("This file has a problem:", path);
+    }
+    const variableDeclarations = ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "VariableDeclaration");
+    return variableDeclarations;
+  }
+  parseTSInterfaceDeclaration(ast, path = "") {
+    const silgi = useSilgiCLI();
+    if (ast.program.body.length === 0) {
+      if (safeFiles.find((i) => path.includes(i)))
+        return [];
+      silgi.errors.push({
+        type: "Parser",
+        path
+      });
+      consola.warn("This file has a problem:", path);
+    }
+    const interfaceDeclarations = ast.program.body.filter((i) => i.type === "ExportNamedDeclaration").filter((i) => i.declaration?.type === "TSInterfaceDeclaration");
+    return interfaceDeclarations;
+  }
+  parseTypeDeclarations(ast, find = "", path = "") {
+    const data = [];
+    const variableDeclarations = this.parseVariableDeclaration(ast, path);
+    for (const item of variableDeclarations) {
+      for (const declaration of item.declaration.declarations) {
+        if (declaration.init?.callee?.name === find) {
+          const options = {};
+          if (declaration.init.arguments) {
+            for (const argument of declaration.init.arguments) {
+              for (const propertie of argument.properties) {
+                if (propertie.key.name === "name")
+                  options.pluginName = propertie.value.value;
+              }
+            }
+          }
+          for (const key in declaration.init.properties) {
+            const property = declaration.init.properties[key];
+            if (property.type === "ObjectProperty") {
+              if (property.key.name === "options") {
+                for (const key2 in property.value.properties) {
+                  const option = property.value.properties[key2];
+                  if (option.type === "ObjectProperty") {
+                    options[option.key.name] = option.value.value;
+                  }
+                }
+              }
+            }
+          }
+          options.type = false;
+          data.push({
+            exportName: declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  parseInterfaceDeclarations(ast, find = "", path = "") {
+    const data = [];
+    for (const item of this.parseTSInterfaceDeclaration(ast, path)) {
+      if (!item?.declaration?.extends)
+        continue;
+      for (const declaration of item?.declaration?.extends) {
+        if (declaration.expression.name === find) {
+          const options = {};
+          options.type = true;
+          data.push({
+            exportName: item.declaration.id.name,
+            options,
+            // object: declaration.init,
+            path
+          });
+        }
+      }
+    }
+    return data;
+  }
+  // private parsePlugin(ast: any, path: string = '') {
+  //   const data = {
+  //     export: [],
+  //     name: '',
+  //     path: '',
+  //   } as DataTypePlugin
+  //   for (const item of this.parseVariableDeclaration(ast)) {
+  //     for (const declaration of item.declaration.declarations) {
+  //       if (declaration.init.callee?.name === 'defineSilgiModule') {
+  //         if (declaration.init.arguments) {
+  //           for (const argument of declaration.init.arguments) {
+  //             for (const propertie of argument.properties) {
+  //               if (propertie.key.name === 'name')
+  //                 data.name = propertie.value.value
+  //             }
+  //           }
+  //         }
+  //         data.export.push({
+  //           name: data.name,
+  //           as: camelCase(`${data.name}DefineSilgiModule`),
+  //           type: false,
+  //         })
+  //       }
+  //     }
+  //   }
+  //   for (const item of this.parseTSInterfaceDeclaration(ast)) {
+  //     if (!item?.declaration?.extends)
+  //       continue
+  //     for (const declaration of item?.declaration?.extends) {
+  //       if (declaration.expression.name === 'ModuleOptions') {
+  //         data.export.push({
+  //           name: item.declaration.id.name,
+  //           as: camelCase(`${data.name}ModuleOptions`),
+  //           type: true,
+  //         })
+  //       }
+  //       // TODO add other plugins
+  //     }
+  //   }
+  //   data.path = path
+  //   return data
+  // }
+}
+
+export { SchemaParser };

package/dist/cli/utils/readScanFile.mjs

@@ -0,0 +1,79 @@
+import { promises } from 'node:fs';
+import { consola } from 'consola';
+import { defu } from 'defu';
+import { createJiti } from 'dev-jiti';
+import { resolve } from 'pathe';
+import { createUnimport } from 'unimport';
+
+async function readScanFile(silgi) {
+  const path = resolve(silgi.options.silgi.serverDir, "scan.ts");
+  const context = await promises.readFile(path, { encoding: "utf-8" });
+  silgi.unimport = createUnimport(silgi.options.imports || {});
+  await silgi.unimport.init();
+  const injectedResult = await silgi.unimport.injectImports(context, path);
+  if (!injectedResult) {
+    throw new Error("Failed to inject imports");
+  }
+  const jiti = createJiti(silgi.options.rootDir, {
+    fsCache: true,
+    moduleCache: false,
+    debug: silgi.options.debug,
+    alias: silgi.options.alias
+  });
+  try {
+    if (silgi.options.commandType === "prepare") {
+      globalThis.$silgiSharedRuntimeConfig = silgi.options.runtimeConfig;
+      injectedResult.code = `globalThis.$silgiSharedRuntimeConfig = ${JSON.stringify(silgi.options.runtimeConfig)};
+${injectedResult.code}`;
+      injectedResult.code = injectedResult.code.replace(/runtimeConfig: \{\}/, `runtimeConfig: ${JSON.stringify(silgi.options.runtimeConfig)}`);
+    }
+    const scanFile = await jiti.evalModule(
+      injectedResult.code,
+      {
+        filename: path,
+        async: true,
+        conditions: silgi.options.conditions
+      },
+      async (data, name) => {
+        return (await silgi.unimport.injectImports(data, name)).code;
+      }
+    );
+    silgi.uris = defu(silgi.uris, scanFile.uris) || {};
+    silgi.schemas = defu(scanFile.schemas, scanFile.uris) || {};
+    silgi.services = defu(scanFile.services, scanFile.uris) || {};
+    silgi.shareds = defu(scanFile.shareds, scanFile.shareds) || {};
+    silgi.modulesURIs = defu(scanFile.modulesURIs, scanFile.modulesURIs) || {};
+    return {
+      context,
+      object: {
+        schemas: scanFile.schemas,
+        uris: scanFile.uris,
+        services: scanFile.services,
+        shareds: scanFile.shareds,
+        modulesURIs: scanFile.modulesURIs
+      },
+      path
+    };
+  } catch (error) {
+    if (silgi.options.debug) {
+      console.error("Failed to read scan.ts file:", error);
+    } else {
+      if (error instanceof Error) {
+        consola.withTag("silgi").info(error.message);
+      }
+    }
+    return {
+      context,
+      object: {
+        schemas: {},
+        uris: {},
+        services: {},
+        shareds: {},
+        modulesURIs: {}
+      },
+      path
+    };
+  }
+}
+
+export { readScanFile };

package/dist/cli/utils/storage.mjs

@@ -0,0 +1,25 @@
+import { klona } from 'klona';
+import { replaceRuntimeValues } from 'silgi';
+import { useSilgiRuntimeConfig } from 'silgi/runtime';
+import { createStorage, builtinDrivers } from 'unstorage';
+
+async function createStorageCLI(silgi) {
+  const storage = createStorage();
+  const runtime = useSilgiRuntimeConfig();
+  const mounts = klona({
+    ...silgi.options.storage,
+    ...silgi.options.devStorage
+  });
+  for (const [path, opts] of Object.entries(mounts)) {
+    if (opts.driver) {
+      const driver = await import(builtinDrivers[opts.driver] || opts.driver).then((r) => r.default || r);
+      const processedOpts = replaceRuntimeValues({ ...opts }, runtime);
+      storage.mount(path, driver(processedOpts));
+    } else {
+      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
+    }
+  }
+  return storage;
+}
+
+export { createStorageCLI };

package/dist/core/createSilgi.mjs

@@ -0,0 +1,76 @@
+import { createConsola } from 'consola';
+import defu from 'defu';
+import { createHooks } from 'hookable';
+import { createRouteRules } from './routeRules.mjs';
+import { silgiCtx } from './unctx.mjs';
+import { scanAction } from './uris/uri.mjs';
+import { createStorage, useSilgiStorage } from './utils/storage.mjs';
+
+async function runSilgiPlugins(silgi) {
+  for (const plugin of silgi.plugins) {
+    try {
+      await plugin(silgi);
+    } catch (error) {
+      silgi.captureError(error, { tags: ["plugin"] });
+      throw error;
+    }
+  }
+}
+async function createSilgi(config) {
+  const hooks = createHooks();
+  const silgi = {
+    schemas: config.schemas,
+    services: config.services ?? {},
+    shared: config.shared ?? void 0,
+    uris: config.uris ?? {},
+    modulesURIs: config.modulesURIs ?? {},
+    scannedHandlers: /* @__PURE__ */ new Map(),
+    plugins: config.plugins ?? [],
+    framework: config.framework ?? void 0,
+    storage: config.options.putStorage ?? void 0,
+    options: config.options ?? {},
+    hooks,
+    callHook: hooks.callHook,
+    addHooks: hooks.addHooks,
+    hook: hooks.hook,
+    ready: () => {
+      return hooks.callHook("ready", silgi);
+    },
+    envOptions: config.envOptions ?? {},
+    close: () => hooks.callHook("close", silgi),
+    logger: createConsola(defu(config.options?.consolaOptions ?? {}, {
+      tag: "silgi"
+    })).withTag("silgi"),
+    captureError: config.captureError ?? (() => {
+    }),
+    routeRules: void 0
+  };
+  const routeRules = createRouteRules();
+  routeRules.importRules(config.options.routeRules ?? {});
+  silgi.routeRules = routeRules;
+  silgi.hooks.addHooks(silgi.options.hooks);
+  await runSilgiPlugins(silgi);
+  await scanAction(silgi);
+  if (!silgi.storage) {
+    silgi.storage = await createStorage(silgi);
+  }
+  silgi.shared.storage = (...data) => {
+    return useSilgiStorage(...data);
+  };
+  silgi.shared.runtimeConfig = silgi.options.runtimeConfig;
+  if (silgiCtx.tryUse()) {
+    silgiCtx.unset();
+    silgiCtx.set(silgi);
+  } else {
+    silgiCtx.set(silgi);
+    silgi.hook("close", () => silgiCtx.unset());
+  }
+  silgi.logger.info("Silgi installed");
+  hooks.hookOnce("close", async () => {
+    hooks.removeAllHooks();
+    await silgi.storage.dispose();
+  });
+  return silgi;
+}
+
+export { createSilgi };