silgi 0.7.1 → 0.7.2

package/dist/cli/core/templates.mjs

@@ -1,29 +0,0 @@
-const vueShim = {
-  filename: "types/vue-shim.d.ts",
-  getContents: ({ app }) => {
-    if (!app.options.typescript.shim) {
-      return "";
-    }
-    return [
-      "declare module '*.vue' {",
-      "  import { DefineComponent } from 'vue'",
-      "  const component: DefineComponent<{}, {}, any>",
-      "  export default component",
-      "}"
-    ].join("\n");
-  }
-};
-const pluginsDeclaration = {
-  filename: "types/plugins.d.ts",
-  getContents: async () => {
-    return `
-      declare module 'nuxt' {
-        interface NuxtApp {
-          $myPlugin: any;
-        }
-      }
-    `;
-  }
-};
-
-export { pluginsDeclaration, vueShim };

package/dist/cli/module/exportScan.mjs

@@ -1,69 +0,0 @@
-import { pascalCase } from 'scule';
-import { relativeWithDot } from 'silgi/kit';
-
-async function registerModuleExportScan(silgi) {
-  silgi.hook("prepare:schema.ts", async (options) => {
-    for (const module of silgi.scanModules) {
-      const exports = module.meta.exports;
-      if (!exports?.length)
-        continue;
-      const configKey = module.meta.configKey;
-      const moduleName = module.meta.name || module.meta._packageName;
-      options.importItems[configKey] = {
-        import: [],
-        from: module.meta._packageName ? moduleName : relativeWithDot(silgi.options.build.typesDir, module.entryPath)
-      };
-      const exportedTypes = exports.filter((exp) => exp.type).map((exp) => exp.name);
-      if (exportedTypes.includes("ModuleOptions")) {
-        const importName = pascalCase(`${configKey}Config`);
-        options.importItems[configKey].import.push({
-          name: `ModuleOptions as ${importName}`,
-          type: true
-        });
-        options.configs.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeContext")) {
-        const importName = pascalCase(`${configKey}Context`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeContext as ${importName}`,
-          type: true
-        });
-        options.contexts.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeMethods")) {
-        const importName = pascalCase(`${configKey}Method`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeMethods as ${importName}`,
-          type: true
-        });
-        options.methods.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeShared")) {
-        const importName = pascalCase(`${configKey}Shared`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeShared as ${importName}`,
-          type: true
-        });
-        options.shareds.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleHooks")) {
-        const importName = pascalCase(`${configKey}Hooks`);
-        options.importItems[configKey].import.push({
-          name: `ModuleHooks as ${importName}`,
-          type: true
-        });
-        options.hooks.push({ key: configKey, value: importName });
-      }
-      if (exportedTypes.includes("ModuleRuntimeHooks")) {
-        const importName = pascalCase(`${configKey}RuntimeHooks`);
-        options.importItems[configKey].import.push({
-          name: `ModuleRuntimeHooks as ${importName}`,
-          type: true
-        });
-        options.runtimeHooks.push({ key: configKey, value: importName });
-      }
-    }
-  });
-}
-
-export { registerModuleExportScan };

package/dist/cli/module/install.mjs

@@ -1,52 +0,0 @@
-import { createJiti } from 'dev-jiti';
-import { useSilgiCLI } from 'silgi/core';
-import { hasInstalledModule } from '../utils/compatibility.mjs';
-
-async function loadSilgiModuleInstance(silgiModule) {
-  if (typeof silgiModule === "string") {
-    throw new TypeError(`Could not load \`${silgiModule}\`. Is it installed?`);
-  }
-  if (typeof silgiModule !== "function") {
-    throw new TypeError(`Nuxt module should be a function: ${silgiModule}`);
-  }
-  return { silgiModule };
-}
-async function installModules(silgi) {
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias
-  });
-  for (const module of silgi.scanModules) {
-    if (hasInstalledModule(module.meta.configKey)) {
-      silgi.logger.info(`Module ${module.meta.configKey} installed`);
-    }
-    try {
-      const silgiModule = await jiti.import(module.entryPath, {
-        default: true,
-        conditions: silgi.options.conditions
-      });
-      if (silgiModule.name !== "silgiNormalizedModule") {
-        silgi.scanModules = silgi.scanModules.filter((m) => m.entryPath !== module.entryPath);
-        continue;
-      }
-      await installModule(silgiModule, silgi);
-    } catch (err) {
-      silgi.logger.error(err);
-    }
-  }
-}
-async function installModule(moduleToInstall, silgi = useSilgiCLI(), inlineOptions) {
-  const { silgiModule } = await loadSilgiModuleInstance(moduleToInstall);
-  const res = await silgiModule({}, silgi) ?? {};
-  if (res === false) {
-    return false;
-  }
-  const metaData = await silgiModule.getMeta?.();
-  const installedModule = silgi.scanModules.find((m) => m.meta.configKey === metaData?.configKey);
-  if (installedModule) {
-    installedModule.installed = true;
-  } else {
-    throw new Error(`Module ${metaData?.name} not found`);
-  }
-}
-
-export { installModules, loadSilgiModuleInstance };

package/dist/cli/module/scan.mjs

@@ -1,141 +0,0 @@
-import { existsSync, promises } from 'node:fs';
-import { pathToFileURL, fileURLToPath } from 'node:url';
-import { consola } from 'consola';
-import { createJiti } from 'dev-jiti';
-import { resolve as resolve$1 } from 'mlly';
-import { resolve, join, isAbsolute } from 'pathe';
-import { resolveAlias, resolvePath } from 'silgi/kit';
-import { isRelative } from 'ufo';
-import { scanExports } from 'unimport';
-
-const logger = consola;
-async function _resolveSilgiModule(mod, silgi) {
-  let _url;
-  let buildTimeModuleMeta = {};
-  const jiti = createJiti(silgi.options.rootDir, {
-    alias: silgi.options.alias
-  });
-  if (typeof mod === "string") {
-    const paths = /* @__PURE__ */ new Set();
-    mod = resolveAlias(mod, silgi.options.alias);
-    if (isRelative(mod)) {
-      mod = resolve(silgi.options.rootDir, mod);
-    }
-    paths.add(join(mod, "module"));
-    paths.add(mod);
-    for (const path of paths) {
-      try {
-        const src = isAbsolute(path) ? pathToFileURL(await resolvePath(path, { fallbackToOriginal: false, extensions: silgi.options.extensions })).href : await resolve$1(path, { url: silgi.options.modulesDir.map((m) => pathToFileURL(m.replace(/\/node_modules\/?$/, ""))), extensions: silgi.options.extensions });
-        mod = await jiti.import(src, {
-          default: true,
-          conditions: silgi.options.conditions
-        });
-        _url = fileURLToPath(new URL(src));
-        const moduleMetadataPath = new URL("module.json", src);
-        if (existsSync(moduleMetadataPath)) {
-          buildTimeModuleMeta = JSON.parse(await promises.readFile(moduleMetadataPath, "utf-8"));
-        } else {
-          if (typeof mod === "function") {
-            const meta = await mod.getMeta?.();
-            const _exports = await scanExports(_url, true);
-            buildTimeModuleMeta = {
-              ...meta,
-              exports: _exports.map(({ from, ...rest }) => rest)
-            };
-          }
-        }
-        break;
-      } catch (error) {
-        const code = error.code;
-        if (code === "MODULE_NOT_FOUND" || code === "ERR_PACKAGE_PATH_NOT_EXPORTED" || code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNSUPPORTED_DIR_IMPORT" || code === "ENOTDIR") {
-          continue;
-        }
-        logger.error(`Error while importing module \`${mod}\`: ${error}`);
-        throw error;
-      }
-    }
-  }
-  if (!buildTimeModuleMeta) {
-    throw new Error(`Module ${mod} is not a valid Silgi module`);
-  }
-  if (typeof mod === "function") {
-    if (silgi.scanModules.some((m) => m.meta?.configKey === buildTimeModuleMeta.configKey)) {
-      throw new Error(`Module with key \`${buildTimeModuleMeta.configKey}\` already exists`);
-    }
-    silgi.scanModules.push({
-      meta: buildTimeModuleMeta,
-      entryPath: _url,
-      installed: false,
-      options: await mod.getOptions?.() || {}
-    });
-  }
-}
-async function scanModules(silgi) {
-  const _modules = [
-    ...silgi.options._modules,
-    ...silgi.options.modules
-  ];
-  for await (const mod of _modules) {
-    await _resolveSilgiModule(mod, silgi);
-  }
-  const moduleMap = new Map(
-    silgi.scanModules.map((m) => [m.meta?.configKey, m])
-  );
-  const graph = createDependencyGraph(silgi.scanModules);
-  const sortedKeys = topologicalSort(graph);
-  const modules = sortedKeys.map((key) => moduleMap.get(key)).filter((module) => Boolean(module));
-  silgi.scanModules = modules;
-}
-function createDependencyGraph(modules) {
-  const graph = /* @__PURE__ */ new Map();
-  modules.forEach((module) => {
-    const key = module.meta?.configKey;
-    if (key) {
-      graph.set(key, /* @__PURE__ */ new Set());
-    }
-  });
-  modules.forEach((module) => {
-    const key = module.meta?.configKey;
-    const deps = module.meta?.dependencies || [];
-    if (key && deps.length > 0) {
-      const modulesDeps = graph.get(key) || /* @__PURE__ */ new Set();
-      deps.forEach((dep) => {
-        if (graph.has(dep)) {
-          modulesDeps.add(dep);
-        }
-      });
-      graph.set(key, modulesDeps);
-    }
-  });
-  return graph;
-}
-function topologicalSort(graph) {
-  const visited = /* @__PURE__ */ new Set();
-  const temp = /* @__PURE__ */ new Set();
-  const order = [];
-  function visit(node) {
-    if (temp.has(node))
-      throw new Error(`Circular dependency detected: ${node}`);
-    if (visited.has(node))
-      return;
-    temp.add(node);
-    const deps = graph.get(node) || /* @__PURE__ */ new Set();
-    for (const dep of deps) {
-      visit(dep);
-    }
-    temp.delete(node);
-    visited.add(node);
-    order.unshift(node);
-  }
-  for (const [node, deps] of graph.entries()) {
-    if (deps.size === 0 && !visited.has(node))
-      visit(node);
-  }
-  for (const node of graph.keys()) {
-    if (!visited.has(node))
-      visit(node);
-  }
-  return order;
-}
-
-export { logger, scanModules };

package/dist/cli/utils/generateRouterDTS.mjs

@@ -1,84 +0,0 @@
-import { promises } from 'node:fs';
-import { resolve } from 'pathe';
-
-async function generateRouterDTS(silgi) {
-  silgi.hook("finish:types", async (data) => {
-    const uris = data.object.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}'>`,
-        params: `ExtractRouterParamsFromURI<'${key}'>['params']`
-      };
-      return acc;
-    }, {});
-    const routerTypes = Object.entries(groupedRoutes).map(([path, methods]) => {
-      const methodEntries = Object.entries(methods).map(([method, { input, output, params }]) => {
-        return `    '${method}': {
-      input: ${input},
-      output: ${output}
-      params: ${params}
-    }`;
-      }).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, ExtractRouterParamsFromURI } 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 {}"
-    ].join("\n");
-    const outputPath = resolve(silgi.options.build.typesDir, "silgi-routes.d.ts");
-    await promises.writeFile(outputPath, context);
-  });
-}
-
-export { generateRouterDTS };

package/dist/cli/utils/ignore.mjs

@@ -1,46 +0,0 @@
-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/readCoreFile.mjs

@@ -1,47 +0,0 @@
-import { promises } from 'node:fs';
-import { createJiti } from 'dev-jiti';
-import { resolve } from 'pathe';
-
-async function readCoreFile(silgi) {
-  const path = resolve(silgi.options.silgi.serverDir, "core.ts");
-  const context = await promises.readFile(path, { encoding: "utf-8" });
-  const injectedResult = await silgi.unimport.injectImports(context, path);
-  if (!injectedResult) {
-    throw new Error("Failed to inject imports");
-  }
-  const jiti = createJiti(silgi.options.rootDir, {
-    fsCache: false,
-    moduleCache: false,
-    debug: silgi.options.debug,
-    alias: silgi.options.alias
-  });
-  const coreFile = 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 = coreFile.uris;
-  silgi.schemas = coreFile.schemas;
-  silgi.services = coreFile.services;
-  silgi.shareds = coreFile.shareds;
-  silgi.modulesURIs = coreFile.modulesURIs;
-  return {
-    context,
-    object: {
-      schemas: coreFile.schemas,
-      uris: coreFile.uris,
-      services: coreFile.services,
-      shareds: coreFile.shareds,
-      modulesURIs: coreFile.modulesURIs
-    },
-    path
-  };
-}
-
-export { readCoreFile };

package/dist/cli/utils/scan.mjs

@@ -1,147 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { readdir } from 'node:fs/promises';
-import { consola } from 'consola';
-import { globby } from 'globby';
-import { dirname, basename, relative, join, resolve, extname } from 'pathe';
-import { SchemaParser } from 'silgi/core';
-import { relativeWithDot } from 'silgi/kit';
-import { withTrailingSlash } from 'ufo';
-import { isIgnored } from './ignore.mjs';
-
-async function scanFiles(silgi) {
-  const filePaths = /* @__PURE__ */ new Set();
-  const scannedPaths = [];
-  const dir = silgi.options.serverDir;
-  const files = (await globby(dir, { cwd: silgi.options.rootDir, ignore: silgi.options.ignore })).sort();
-  if (files.length) {
-    const siblings = await readdir(dirname(dir)).catch(() => []);
-    const directory = basename(dir);
-    if (!siblings.includes(directory)) {
-      const directoryLowerCase = directory.toLowerCase();
-      const caseCorrected = siblings.find((sibling) => sibling.toLowerCase() === directoryLowerCase);
-      if (caseCorrected) {
-        const original = relative(silgi.options.serverDir, dir);
-        const corrected = relative(silgi.options.serverDir, join(dirname(dir), caseCorrected));
-        consola.warn(`Components not scanned from \`~/${corrected}\`. Did you mean to name the directory \`~/${original}\` instead?`);
-      }
-    }
-  }
-  for (const _file of files) {
-    const filePath = resolve(dir, _file);
-    if (scannedPaths.find((d) => filePath.startsWith(withTrailingSlash(d))) || isIgnored(filePath, silgi)) {
-      continue;
-    }
-    if (filePaths.has(filePath)) {
-      continue;
-    }
-    filePaths.add(filePath);
-    if (silgi.options.extensions.includes(extname(filePath))) {
-      const parser = new SchemaParser({
-        debug: false
-      });
-      const readfile = readFileSync(filePath, "utf-8");
-      const { exportVariables, parseInterfaceDeclarations } = parser.parseExports(readfile, filePath);
-      const createServices = exportVariables("createService", filePath);
-      if (createServices.length > 0) {
-        for (const createService of createServices) {
-          const { exportName, path } = createService;
-          silgi.hook("prepare:core.ts", (options) => {
-            options.services.push(exportName);
-          });
-          silgi.hook("prepare:core.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: exportName
-            });
-          });
-        }
-      }
-      const createSchemas = exportVariables("createSchema", filePath);
-      if (createSchemas.length > 0) {
-        for (const createSchema of createSchemas) {
-          const { exportName, path } = createSchema;
-          silgi.hook("prepare:core.ts", (options) => {
-            options.schemas.push(exportName);
-          });
-          silgi.hook("prepare:core.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: exportName
-            });
-          });
-        }
-      }
-      const createShareds = exportVariables("createShared", filePath);
-      if (createShareds.length > 0) {
-        for (const createShared of createShareds) {
-          const { exportName, path } = createShared;
-          silgi.hook("prepare:core.ts", (options) => {
-            options.shareds.push(exportName);
-          });
-          silgi.hook("prepare:core.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              // Relative path kaldirmamiz gerekiyor bunlar hooklarin bittigi yerde karar verilmeli.
-              from: relativeWithDot(silgi.options.silgi.serverDir, path)
-            };
-            options.importItems[path].import.push({
-              name: exportName
-            });
-          });
-        }
-      }
-      const sharedsTypes = parseInterfaceDeclarations("ExtendShared", filePath);
-      if (sharedsTypes.length > 0) {
-        for (const sharedType of sharedsTypes) {
-          const { exportName, path } = sharedType;
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.shareds.push({
-              key: exportName,
-              value: exportName
-            });
-          });
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importItems[path].import.push({
-              name: exportName,
-              type: true
-            });
-          });
-        }
-      }
-      const contextTypes = parseInterfaceDeclarations("ExtendContext", filePath);
-      if (contextTypes.length > 0) {
-        for (const contextType of contextTypes) {
-          const { exportName, path } = contextType;
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.contexts.push({
-              key: exportName,
-              value: exportName
-            });
-          });
-          silgi.hook("prepare:schema.ts", (options) => {
-            options.importItems[path] ??= {
-              import: [],
-              from: path
-            };
-            options.importItems[path].import.push({
-              name: exportName,
-              type: true
-            });
-          });
-        }
-      }
-    }
-  }
-}
-
-export { scanFiles };

package/dist/cli/utils/storage.mjs

@@ -1,21 +0,0 @@
-import { klona } from 'klona';
-import { createStorage, builtinDrivers } from 'unstorage';
-
-async function createStorageCLI(silgi) {
-  const storage = createStorage();
-  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);
-      storage.mount(path, driver(opts));
-    } else {
-      silgi.logger.warn(`No \`driver\` set for storage mount point "${path}".`);
-    }
-  }
-  return storage;
-}
-
-export { createStorageCLI };