@stacksjs/server 0.70.87 → 0.70.90

package/dist/config-production.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Production server config - minimal, no runtime file loading
+ * This config is inlined at build time for compiled binaries
+ * @defaultValue `{ server: { host: '0.0.0.0' } }`
+ */
+export declare const config: {
+  app: {
+  name: unknown;
+  env: unknown;
+  debug: boolean;
+  url: unknown
+};
+  server: {
+  port: unknown;
+  /** @defaultValue '0.0.0.0' */
+  host: string
+};
+  logging: {
+  level: unknown
+}
+};
+export default config;

package/dist/config-production.js

@@ -0,0 +1,16 @@
+export const config = {
+  app: {
+    name: process.env.APP_NAME || "Stacks",
+    env: process.env.APP_ENV || "production",
+    debug: process.env.APP_DEBUG === "true" || !1,
+    url: process.env.APP_URL || "https://stacksjs.com"
+  },
+  server: {
+    port: Number(process.env.PORT) || 3000,
+    host: "0.0.0.0"
+  },
+  logging: {
+    level: process.env.LOG_LEVEL || "info"
+  }
+};
+export default config;

package/dist/config.js

@@ -0,0 +1,60 @@
+import { ports } from "@stacksjs/config";
+export function config(options) {
+  const serversMap = {
+    frontend: {
+      host: "localhost",
+      port: ports.frontend
+    },
+    backend: {
+      host: "localhost",
+      port: ports.backend
+    },
+    api: {
+      host: "localhost",
+      port: ports.api
+    },
+    admin: {
+      host: "localhost",
+      port: ports.admin
+    },
+    library: {
+      host: "localhost",
+      port: ports.library
+    },
+    desktop: {
+      host: "localhost",
+      port: ports.desktop
+    },
+    docs: {
+      host: "localhost",
+      port: ports.docs
+    },
+    email: {
+      host: "localhost",
+      port: ports.email
+    },
+    inspect: {
+      host: "localhost",
+      port: ports.inspect
+    },
+    "system-tray": {
+      host: "localhost",
+      port: ports.systemTray
+    },
+    database: {
+      host: "localhost",
+      port: ports.database
+    }
+  };
+  if (options.type && options.type in serversMap)
+    return {
+      host: serversMap[options.type].host,
+      port: serversMap[options.type].port,
+      open: !1
+    };
+  return {
+    host: options.host || "stacks.localhost",
+    port: options.port || 3000,
+    open: !1
+  };
+}

package/dist/controllers/base.js

@@ -0,0 +1,38 @@
+import { log } from "@stacksjs/logging";
+import { response } from "@stacksjs/router";
+
+export class Controller {
+  json(data, status = 200) {
+    return response.json(data, status);
+  }
+  success(data) {
+    return this.json(data, 200);
+  }
+  created(data) {
+    return this.json(data, 201);
+  }
+  noContent() {
+    return response.noContent();
+  }
+  error(message, status = 500) {
+    return this.json({ error: message }, status);
+  }
+  notFound(message = "Resource not found") {
+    return this.error(message, 404);
+  }
+  unauthorized(message = "Unauthorized") {
+    return this.error(message, 401);
+  }
+  forbidden(message = "Forbidden") {
+    return this.error(message, 403);
+  }
+  validate(request, rules) {
+    try {
+      const result = request.validate(rules);
+      log.info("Validation result:", result);
+      return Promise.resolve();
+    } catch (error) {
+      return Promise.reject(error);
+    }
+  }
+}

package/dist/imports.js

@@ -0,0 +1,224 @@
+import { existsSync } from "node:fs";
+import { dirname, relative } from "node:path";
+import { plugin } from "bun";
+import { log } from "@stacksjs/logging";
+import { path } from "@stacksjs/path";
+import { autoImports, generateRuntimeIndex, generateGlobalsScript } from "bun-plugin-auto-imports";
+import { globSync } from "@stacksjs/storage";
+const OPTIONAL_MODEL_MODULES = {
+  commerce: ["config/commerce.ts"],
+  Content: ["config/cms.ts", "config/blog.ts"],
+  realtime: ["config/realtime.ts"]
+};
+function configEnabled(configRelPaths) {
+  return configRelPaths.some((rel) => existsSync(path.projectPath(rel)));
+}
+function resolveDefaultModelDirs() {
+  const root = path.storagePath("framework/defaults/app/Models"), dirs = [root];
+  for (const [subdir, configPaths] of Object.entries(OPTIONAL_MODEL_MODULES))
+    if (configEnabled(configPaths))
+      dirs.push(`${root}/${subdir}`);
+  return dirs;
+}
+function scanDirTopLevel(dir) {
+  try {
+    return globSync(`${dir}/*.ts`, { ignore: ["**/*.d.ts", "**/index.ts", "**/README*"] });
+  } catch {
+    return [];
+  }
+}
+function scanDefineModelExports(dir, opts = {}) {
+  const { recursive = !0 } = opts;
+  let files = [];
+  try {
+    const pattern = recursive ? `${dir}/**/*.ts` : `${dir}/*.ts`;
+    files = globSync(pattern, { ignore: ["**/*.d.ts", "**/index.ts", "**/README*"] });
+  } catch {
+    return [];
+  }
+  const exports = [], seen = new Set;
+  for (const file of files) {
+    const basename = file.split("/").pop()?.replace(".ts", "") || "";
+    if (basename && !seen.has(basename)) {
+      seen.add(basename);
+      exports.push({ name: basename, file, isDefault: !0 });
+    }
+  }
+  return exports;
+}
+const GLOBAL_SHADOW_BLOCKLIST = new Set([
+  "Error",
+  "Request",
+  "Response",
+  "URL",
+  "Map",
+  "Set",
+  "Object",
+  "Array",
+  "Number",
+  "String",
+  "Date",
+  "Promise",
+  "Symbol"
+]);
+async function generateDefineModelIndex(entries, outputPath) {
+  const lines = ["// Generated by bun-plugin-auto-imports"], seen = new Set;
+  for (const entry of entries) {
+    const dir = typeof entry === "string" ? entry : entry.dir, recursive = typeof entry === "string" ? !0 : entry.recursive;
+    let files = [];
+    try {
+      const pattern = recursive ? `${dir}/**/*.ts` : `${dir}/*.ts`;
+      files = globSync(pattern, { ignore: ["**/*.d.ts", "**/index.ts", "**/README*"] });
+    } catch {
+      continue;
+    }
+    for (const file of files) {
+      const basename = file.split("/").pop()?.replace(".ts", "") || "";
+      if (!basename || seen.has(basename))
+        continue;
+      seen.add(basename);
+      const relativePath = relative(dirname(outputPath), file).replace(/\.ts$/, "");
+      if (GLOBAL_SHADOW_BLOCKLIST.has(basename)) {
+        lines.push(`// Skipped '${basename}' \u2014 would shadow a built-in global. Import directly if needed.`);
+        lines.push(`// export { default as ${basename} } from '${relativePath}'`);
+        continue;
+      }
+      lines.push(`export { default as ${basename} } from '${relativePath}'`);
+    }
+  }
+  await Bun.write(outputPath, lines.join(`
+`) + `
+`);
+}
+export async function generateAutoImportFiles() {
+  const userFunctionsPath = path.resourcesPath("functions"), defaultFunctionsPath = path.storagePath("framework/defaults/functions"), functionsPath = userFunctionsPath, outputDir = path.storagePath("framework/auto-imports"), userModelsPath = path.userModelsPath(), defaultModelDirs = resolveDefaultModelDirs(), [defaultsRoot = path.storagePath("framework/defaults/app/Models"), ...enabledSubdirs] = defaultModelDirs, userJobsPath = path.userJobsPath(), userControllersPath = path.userControllersPath(), defaultControllersPath = path.storagePath("framework/defaults/app/Controllers");
+  await Bun.write(`${outputDir}/.gitkeep`, "");
+  const functionsIndexPath = `${outputDir}/functions.ts`;
+  await generateRuntimeIndex([userFunctionsPath, defaultFunctionsPath], functionsIndexPath);
+  const modelsIndexPath = `${outputDir}/models.ts`, modelScan = [
+    userModelsPath,
+    { dir: defaultsRoot, recursive: !1 },
+    ...defaultModelDirs.slice(1).map((d) => ({ dir: d, recursive: !0 }))
+  ];
+  await generateDefineModelIndex(modelScan, modelsIndexPath);
+  const jobsIndexPath = `${outputDir}/jobs.ts`;
+  await generateDefineModelIndex([userJobsPath], jobsIndexPath);
+  const controllersIndexPath = `${outputDir}/controllers.ts`;
+  await generateDefineModelIndex([userControllersPath, defaultControllersPath], controllersIndexPath);
+  const combinedContent = `// Generated by bun-plugin-auto-imports
+export * from './functions'
+export * from './models'
+export * from './jobs'
+export * from './controllers'
+`;
+  await Bun.write(`${outputDir}/index.ts`, combinedContent);
+  const globalsPath = `${outputDir}/globals.ts`;
+  await generateGlobalsScript([functionsPath], globalsPath, `${outputDir}/index.ts`);
+  log.debug("Auto-import files generated successfully");
+}
+export function initiateImports() {
+  const functionsPath = path.resourcesPath("functions"), defaultFunctionsPath = path.storagePath("framework/defaults/functions"), userModelsPath = path.userModelsPath(), defaultModelDirs = resolveDefaultModelDirs(), [defaultsRoot = path.storagePath("framework/defaults/app/Models"), ...enabledSubdirs] = defaultModelDirs, userJobsPath = path.userJobsPath(), userControllersPath = path.userControllersPath(), defaultControllersPath = path.storagePath("framework/defaults/app/Controllers"), defineModelExports = [
+    ...scanDefineModelExports(userModelsPath),
+    ...scanDefineModelExports(defaultsRoot, { recursive: !1 }),
+    ...enabledSubdirs.flatMap((d) => scanDefineModelExports(d))
+  ], jobExports = scanDefineModelExports(userJobsPath), seen = new Set, uniqueDefineModelExports = defineModelExports.filter((exp) => {
+    if (seen.has(exp.name))
+      return !1;
+    seen.add(exp.name);
+    return !0;
+  }), dtsDir = dirname(path.storagePath("framework/types/server-auto-imports.d.ts")), defineModelImports = uniqueDefineModelExports.map((exp) => ({
+    from: `./${relative(dtsDir, exp.file).replace(/\\/g, "/").replace(/\.ts$/, "")}`,
+    name: "default",
+    as: exp.name
+  })), jobImports = jobExports.map((exp) => ({
+    from: `./${relative(dtsDir, exp.file).replace(/\\/g, "/").replace(/\.ts$/, "")}`,
+    name: "default",
+    as: exp.name
+  })), controllerExports = [
+    ...scanDefineModelExports(userControllersPath),
+    ...scanDefineModelExports(defaultControllersPath)
+  ], seenControllers = new Set, controllerImports = controllerExports.filter((exp) => {
+    if (seenControllers.has(exp.name))
+      return !1;
+    seenControllers.add(exp.name);
+    return !0;
+  }).map((exp) => ({
+    from: `./${relative(dtsDir, exp.file).replace(/\\/g, "/").replace(/\.ts$/, "")}`,
+    name: "default",
+    as: exp.name
+  })), options = {
+    dts: path.storagePath("framework/types/server-auto-imports.d.ts"),
+    imports: [...defineModelImports, ...jobImports, ...controllerImports],
+    dirs: [functionsPath, defaultFunctionsPath],
+    eslint: {
+      enabled: !0,
+      filepath: path.storagePath("framework/server-auto-imports.json")
+    }
+  };
+  plugin(autoImports(options));
+  generateAutoImportFiles().catch((err) => {
+    console.error("[Server] Failed to generate auto-import files:", err);
+  });
+}
+export async function injectGlobalAutoImports() {
+  if (globalThis.__stacksAutoImportsInjected)
+    return;
+  globalThis.__stacksAutoImportsInjected = !0;
+  const errors = [], primitiveModules = [
+    ["@stacksjs/types", ["Every", "ExitCode"]],
+    ["@stacksjs/path", ["path"]],
+    ["@stacksjs/error-handling", ["HttpError", "handleError"]],
+    ["@stacksjs/logging", ["log"]],
+    ["@stacksjs/config", ["config"]],
+    ["@stacksjs/validation", ["schema"]],
+    ["@stacksjs/router", ["response", "request", "route", "Middleware", "url"]],
+    ["@stacksjs/storage", ["storage", "fs"]],
+    ["@stacksjs/orm", ["defineModel", "toAttrs"]],
+    ["@stacksjs/database", ["db", "sql"]],
+    ["@stacksjs/email", ["mail", "template"]],
+    ["@stacksjs/queue", ["Job"]],
+    ["@stacksjs/scheduler", ["schedule"]],
+    ["@stacksjs/actions", ["Action"]],
+    ["@stacksjs/auth", ["Auth", "register", "sessionCheck"]],
+    ["@stacksjs/events", ["dispatch", "listen", "emitter"]],
+    ["@stacksjs/feature-flags", ["Feature"]],
+    ["@stacksjs/security", ["makeHash", "verifyHash"]],
+    ["@stacksjs/collections", ["collect"]],
+    ["@stacksjs/cli", ["quotes"]],
+    ["@stacksjs/notifications", ["notify", "useNotification", "useEmail", "useSMS", "useChat", "useDatabase"]],
+    ["@stacksjs/realtime", ["emit", "emitToUser", "emitToUsers", "createChannel", "dispatchBroadcast"]],
+    ["@stacksjs/i18n", ["I18n", "t", "tc", "te", "setLocale", "getLocale"]],
+    ["@stacksjs/stx", ["state", "derived", "effect"]],
+    ["@stacksjs/browser", ["useDark", "usePreferredDark", "useToggle", "useStorage"]]
+  ], importWithTimeout = async (pkg) => {
+    return Promise.race([
+      import(pkg),
+      new Promise((_, reject) => setTimeout(() => reject(Error(`auto-import timed out: ${pkg}`)), 4000))
+    ]);
+  };
+  await Promise.all(primitiveModules.map(async ([pkg, names]) => {
+    try {
+      const mod = await importWithTimeout(pkg);
+      for (const name of names)
+        if (mod[name] !== void 0)
+          globalThis[name] = mod[name];
+    } catch (err) {
+      errors.push(err);
+    }
+  }));
+  try {
+    const { ensureLocalesLoaded } = await import("@stacksjs/i18n");
+    await ensureLocalesLoaded();
+  } catch (err) {
+    errors.push(err);
+  }
+  try {
+    const autoImports = await import(path.storagePath("framework/auto-imports/index.ts"));
+    Object.assign(globalThis, autoImports);
+  } catch (err) {
+    errors.push(err);
+  }
+  if (errors.length)
+    for (const err of errors)
+      console.warn("[auto-imports]", err.message);
+}