silgi 0.7.0 → 0.7.1

package/dist/cli/utils/readCoreFile.mjs

@@ -0,0 +1,47 @@
+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

@@ -0,0 +1,147 @@
+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

@@ -0,0 +1,21 @@
+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 };

package/dist/cli/utils/uri.mjs

@@ -0,0 +1,71 @@
+function traverseObject(silgi, obj, currentPath = []) {
+  const uriMap = /* @__PURE__ */ new Map();
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (path.length === 4) {
+      const basePath = path.join("/");
+      let paramString = "";
+      if (node.router) {
+        let params = null;
+        if (node.router?._def?.typeName !== void 0) {
+          try {
+            const shape = node.router?.shape?.params?.shape;
+            params = shape ? Object.keys(shape) : null;
+          } catch {
+            params = null;
+          }
+        }
+        if (params?.length) {
+          paramString = params.map((p) => `:${p}`).join("/");
+        }
+      }
+      uriMap.set(basePath, paramString);
+      return;
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(obj, currentPath);
+  return uriMap;
+}
+function scanActionModulesUris(silgi, obj, currentPath = []) {
+  const uriMap = {};
+  function traverse(node, path = []) {
+    if (!node || typeof node !== "object")
+      return;
+    if (path.length === 4) {
+      const basePath = path.join("/");
+      let moduleName = "";
+      if (node.modules?.yoga) {
+        let rootFieldName = null;
+        if (node.modules?.yoga?.rootFieldName) {
+          moduleName = "yoga";
+          rootFieldName = node.modules?.yoga?.rootFieldName;
+        }
+        if (!rootFieldName) {
+          return;
+        }
+        uriMap[moduleName] ??= {};
+        if (uriMap[moduleName].rootFieldName) {
+          silgi.logger.withTag("scanActionModulesUris").error(`Hata ${moduleName} ${rootFieldName} ${basePath} bu zaten burada kullanilmis.`);
+        }
+        uriMap[moduleName].rootFieldName ??= {};
+        uriMap[moduleName].rootFieldName[rootFieldName] = basePath;
+      }
+      return;
+    }
+    for (const key in node) {
+      if (!["_type", "fields"].includes(key)) {
+        traverse(node[key], [...path, key]);
+      }
+    }
+  }
+  traverse(obj, currentPath);
+  return uriMap;
+}
+
+export { scanActionModulesUris, traverseObject };

package/dist/core/config/defaults.mjs

@@ -0,0 +1,96 @@
+import { isDebug, isTest } from 'std-env';
+
+const SilgiCLIDefaults = {
+  // General
+  debug: isDebug,
+  // timing: isDebug,
+  logLevel: isTest ? 1 : 3,
+  // runtimeConfig: { app: {}, silgi: {} },
+  appConfig: {},
+  appConfigFiles: [],
+  // Dirs
+  scanDirs: [],
+  build: {
+    dir: ".silgi",
+    typesDir: "{{ build.dir }}/types",
+    templates: []
+  },
+  output: {
+    dir: "{{ rootDir }}/.output",
+    serverDir: "{{ output.dir }}/server",
+    publicDir: "{{ output.dir }}/public"
+  },
+  serverDir: "{{ rootDir }}/server",
+  clientDir: "{{ rootDir }}/client",
+  silgi: {
+    serverDir: "{{ serverDir }}/silgi",
+    clientDir: "{{ clientDir }}/silgi",
+    publicDir: "{{ silgi.serverDir }}/public",
+    utilsDir: "{{ silgi.serverDir }}/utils",
+    vfsDir: "{{ silgi.serverDir }}/vfs",
+    typesDir: "{{ silgi.serverDir }}/types"
+  },
+  // Modules
+  _modules: [],
+  modules: [],
+  // Features
+  // experimental: {},
+  future: {},
+  storage: {},
+  devStorage: {},
+  stub: false,
+  // bundledStorage: [],
+  // publicAssets: [],
+  // serverAssets: [],
+  plugins: [],
+  // tasks: {},
+  // scheduledTasks: {},
+  imports: {
+    exclude: [],
+    dirs: [],
+    presets: [],
+    virtualImports: ["#silgiImports"]
+  },
+  // virtual: {},
+  // compressPublicAssets: false,
+  ignore: [],
+  // Dev
+  dev: false,
+  // devServer: { watch: [] },
+  watchOptions: { ignoreInitial: true },
+  // devProxy: {},
+  // Logging
+  // logging: {
+  //   compressedSizes: true,
+  //   buildSuccess: true,
+  // },
+  // Routing
+  // baseURL: process.env.NITRO_APP_BASE_URL || '/',
+  // handlers: [],
+  // devHandlers: [],
+  // errorHandler: undefined,
+  // routeRules: {},
+  // Advanced
+  typescript: {
+    strict: false,
+    generateTsConfig: true,
+    // generateRuntimeConfigTypes: true,
+    tsconfigPath: "types/silgi.tsconfig.json",
+    internalPaths: false,
+    tsConfig: {},
+    customConditions: []
+  },
+  conditions: [],
+  nodeModulesDirs: [],
+  // hooks: {},
+  commands: {},
+  // Framework
+  framework: {
+    name: "h3",
+    version: ""
+  },
+  extensions: [".js", ".jsx", ".mjs", ".ts", ".tsx", ".vue"],
+  ignoreOptions: void 0
+};
+
+export { SilgiCLIDefaults };

package/dist/core/config/loader.mjs

@@ -0,0 +1,98 @@
+import { watchConfig, loadConfig } from 'c12';
+import { resolveCompatibilityDates } from 'compatx';
+import { klona } from 'klona/full';
+import { SilgiCLIDefaults } from './defaults.mjs';
+import { resolveCompatibilityOptions, fallbackCompatibilityDate } from './resolvers/compatibility.mjs';
+import { resolveImportsOptions } from './resolvers/imports.mjs';
+import { resolvePathOptions } from './resolvers/paths.mjs';
+import { resolveStorageOptions } from './resolvers/storage.mjs';
+import { resolveURLOptions } from './resolvers/url.mjs';
+
+const configResolvers = [
+  resolveCompatibilityOptions,
+  resolvePathOptions,
+  resolveImportsOptions,
+  // resolveRouteRulesOptions,
+  // resolveDatabaseOptions,
+  // resolveFetchOptions,
+  // resolveExportConditionsOptions,
+  // resolveRuntimeConfigOptions,
+  // resolveOpenAPIOptions,
+  resolveURLOptions,
+  // resolveAssetsOptions,
+  resolveStorageOptions
+  // resolveErrorOptions,
+];
+async function loadOptions(configOverrides = {}, opts = {}) {
+  const options = await _loadUserConfig(configOverrides, opts);
+  for (const resolver of configResolvers) {
+    await resolver(options);
+  }
+  return options;
+}
+async function _loadUserConfig(configOverrides = {}, opts = {}) {
+  const presetOverride = configOverrides.preset || process.env.SILGI_PRESET;
+  if (configOverrides.dev) ;
+  configOverrides = klona(configOverrides);
+  globalThis.defineSilgiConfig = globalThis.defineSilgiConfig || ((c) => c);
+  let compatibilityDate = configOverrides.compatibilityDate || opts.compatibilityDate || (process.env.SILGI_COMPATIBILITY_DATE || process.env.SERVER_COMPATIBILITY_DATE || process.env.COMPATIBILITY_DATE);
+  const { resolvePreset } = await import('silgi/presets');
+  const loadedConfig = await (opts.watch ? watchConfig : loadConfig)({
+    name: "silgi",
+    cwd: configOverrides.rootDir,
+    dotenv: configOverrides.dev,
+    extend: { extendKey: ["extends", "preset"] },
+    overrides: {
+      ...configOverrides,
+      preset: presetOverride
+    },
+    async defaultConfig({ configs }) {
+      const getConf = (key) => configs.main?.[key] ?? configs.rc?.[key] ?? configs.packageJson?.[key];
+      if (!compatibilityDate) {
+        compatibilityDate = getConf("compatibilityDate");
+      }
+      return {
+        // typescript: {
+        //   generateRuntimeConfigTypes:
+        //     !framework?.name || framework.name === 'nitro',
+        // },
+        preset: presetOverride || (await resolvePreset("", {
+          static: getConf("static"),
+          compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+        }))?._meta?.name
+      };
+    },
+    defaults: SilgiCLIDefaults,
+    jitiOptions: {
+      alias: {
+        "silgi": "silgi/config",
+        "silgi/config": "silgi/config"
+      }
+    },
+    async resolve(id) {
+      const preset = await resolvePreset(id, {
+        static: configOverrides.static,
+        compatibilityDate: compatibilityDate || fallbackCompatibilityDate
+      });
+      if (preset) {
+        return {
+          config: klona(preset)
+        };
+      }
+    },
+    ...opts.c12
+  });
+  delete globalThis.defineSilgiConfig;
+  const options = klona(loadedConfig.config);
+  options._config = configOverrides;
+  options._c12 = loadedConfig;
+  const _presetName = (loadedConfig.layers || []).find((l) => l.config?._meta?.name)?.config?._meta?.name || presetOverride;
+  options.preset = _presetName;
+  options.compatibilityDate = resolveCompatibilityDates(
+    compatibilityDate,
+    options.compatibilityDate
+  );
+  return options;
+}
+
+export { loadOptions };

package/dist/core/config/resolvers/compatibility.mjs

@@ -0,0 +1,90 @@
+import { resolveCompatibilityDatesFromEnv, formatDate } from 'compatx';
+import consola from 'consola';
+import { colors } from 'consola/utils';
+import { relative } from 'pathe';
+
+const fallbackCompatibilityDate = "2025-02-04";
+async function resolveCompatibilityOptions(options) {
+  options.compatibilityDate = resolveCompatibilityDatesFromEnv(
+    options.compatibilityDate
+  );
+  if (!options.compatibilityDate.default) {
+    options.compatibilityDate.default = await _resolveDefault(options);
+  }
+}
+let _fallbackInfoShown = false;
+let _promptedUserToUpdate = false;
+async function _resolveDefault(options) {
+  const _todayDate = formatDate(/* @__PURE__ */ new Date());
+  const consola$1 = consola.withTag("silgi");
+  consola$1.warn(`No valid compatibility date is specified.`);
+  const onFallback = () => {
+    if (!_fallbackInfoShown) {
+      consola$1.info(
+        [
+          `Using \`${fallbackCompatibilityDate}\` as fallback.`,
+          `  Please specify compatibility date to avoid unwanted behavior changes:`,
+          `     - Add \`compatibilityDate: '${_todayDate}'\` to the config file.`,
+          `     - Or set \`COMPATIBILITY_DATE=${_todayDate}\` environment variable.`,
+          ``
+        ].join("\n")
+      );
+      _fallbackInfoShown = true;
+    }
+    return fallbackCompatibilityDate;
+  };
+  const shallUpdate = !_promptedUserToUpdate && await consola$1.prompt(
+    `Do you want to auto update config file to set ${colors.cyan(`compatibilityDate: '${_todayDate}'`)}?`,
+    {
+      type: "confirm",
+      default: true
+    }
+  );
+  _promptedUserToUpdate = true;
+  if (!shallUpdate) {
+    return onFallback();
+  }
+  const { updateConfig } = await import('c12/update');
+  const updateResult = await updateConfig({
+    configFile: "silgi.config",
+    cwd: options.rootDir,
+    async onCreate({ configFile }) {
+      const shallCreate = await consola$1.prompt(
+        `Do you want to initialize a new config in ${colors.cyan(relative(".", configFile))}?`,
+        {
+          type: "confirm",
+          default: true
+        }
+      );
+      if (shallCreate !== true) {
+        return false;
+      }
+      return _getDefaultNitroConfig();
+    },
+    async onUpdate(config) {
+      config.compatibilityDate = _todayDate;
+    }
+  }).catch((error) => {
+    consola$1.error(`Failed to update config: ${error.message}`);
+    return null;
+  });
+  if (updateResult?.configFile) {
+    consola$1.success(
+      `Compatibility date set to \`${_todayDate}\` in \`${relative(".", updateResult.configFile)}\``
+    );
+    return _todayDate;
+  }
+  return onFallback();
+}
+function _getDefaultNitroConfig() {
+  return (
+    /* js */
+    `
+import { defineSilgiConfig } from 'silgi/config'
+
+export default defineSilgiConfig({})
+  `
+  );
+}
+
+export { fallbackCompatibilityDate, resolveCompatibilityOptions };

package/dist/core/config/resolvers/imports.mjs

@@ -0,0 +1,96 @@
+import escapeRE from 'escape-string-regexp';
+import { resolveModuleExportNames } from 'mlly';
+import { join } from 'pathe';
+
+async function resolveImportsOptions(options) {
+  if (options.imports === false) {
+    return;
+  }
+  options.imports.presets ??= [];
+  options.imports.presets.push(...getSilgiImportsPreset());
+  if (options.preset === "h3") {
+    const h3Exports = await resolveModuleExportNames("h3", {
+      url: import.meta.url
+    });
+    options.imports.presets ??= [];
+    options.imports.presets.push({
+      from: "h3",
+      imports: h3Exports.filter((n) => !/^[A-Z]/.test(n) && n !== "use")
+    });
+  }
+  options.imports.dirs ??= [];
+  options.imports.dirs.push(
+    ...options.scanDirs.map((dir) => join(dir, "utils/**/*"))
+  );
+  if (Array.isArray(options.imports.exclude) && options.imports.exclude.length === 0) {
+    options.imports.exclude.push(/[/\\]\.git[/\\]/);
+    options.imports.exclude.push(options.build.dir);
+    const scanDirsInNodeModules = options.scanDirs.map((dir) => dir.match(/(?<=\/)node_modules\/(.+)$/)?.[1]).filter(Boolean);
+    options.imports.exclude.push(
+      scanDirsInNodeModules.length > 0 ? new RegExp(
+        `node_modules\\/(?!${scanDirsInNodeModules.map((dir) => escapeRE(dir)).join("|")})`
+      ) : /[/\\]node_modules[/\\]/
+    );
+  }
+}
+function getSilgiImportsPreset() {
+  return [
+    // TODO: buraya bizim importlarimiz gelecek.
+    {
+      from: "silgi",
+      imports: [
+        "createShared",
+        "useSilgi",
+        "createService",
+        "createSchema"
+      ]
+    },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['useRuntimeConfig', 'useAppConfig'],
+    // },
+    // {
+    //   from: 'nitropack/runtime',
+    //   imports: ['defineNitroPlugin', 'nitroPlugin'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/cache',
+    //   imports: [
+    //     'defineCachedFunction',
+    //     'defineCachedEventHandler',
+    //     'cachedFunction',
+    //     'cachedEventHandler',
+    //   ],
+    // },
+    {
+      from: "silgi/core",
+      imports: ["useSilgiStorage"]
+    }
+    // {
+    //   from: 'nitropack/runtime/internal/renderer',
+    //   imports: ['defineRenderHandler'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/meta',
+    //   imports: ['defineRouteMeta'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/route-rules',
+    //   imports: ['getRouteRules'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/context',
+    //   imports: ['useEvent'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/task',
+    //   imports: ['defineTask', 'runTask'],
+    // },
+    // {
+    //   from: 'nitropack/runtime/internal/error/utils',
+    //   imports: ['defineNitroErrorHandler'],
+    // },
+  ];
+}
+
+export { resolveImportsOptions };