@stacksjs/buddy 0.70.255 → 0.70.257

package/dist/commands/deploy.d.ts

@@ -43,6 +43,74 @@ export declare function resolveDeployEnvValues(environment: 'production' | 'stag
  * the process env).
  */
 export declare function mergeSiteDeployEnv(sites: Record<string, any>, resolvedDeployEnv: Record<string, string>): Record<string, any>;
+/**
+ * The SQLite file a site will open, relative to its release root — or `null`
+ * when the site is not on SQLite, or its database already lives outside the
+ * release tree (an absolute `DB_DATABASE_PATH` is the operator saying "I have
+ * placed this somewhere persistent myself").
+ *
+ * Mirrors config/database.ts' resolution order. `DB_DATABASE` is only a path
+ * when it looks like one — for every other driver it is a database NAME, and
+ * linking `stacks` as a file would be nonsense.
+ */
+export declare function siteSqlitePath(siteEnv?: Record<string, any>): string | null;
+/**
+ * Does the loaded ts-cloud actually keep persistent state the way
+ * {@link applyPersistentStatePaths} assumes?
+ *
+ * Declaring shared paths against a ts-cloud that lacks these is worse than not
+ * declaring them at all — it is the difference between "the database dies with
+ * its release" and "the deploy places an empty database over the live one and
+ * migrates into it". So this probes the two capabilities the declaration
+ * depends on and lets the caller refuse the deploy.
+ *
+ * Probed by generating a script and reading what it DOES, not by a version
+ * number or an exported symbol name: a version range goes stale the moment
+ * someone installs a fork, and an internal helper can be renamed without
+ * changing behaviour.
+ *
+ * @param buildSiteDeployScript ts-cloud's script builder, as loaded at runtime.
+ */
+export declare function tsCloudPersistentStateSupport(buildSiteDeployScript: unknown): { ok: boolean, missing: string[] };
+/**
+ * Where a project's app database lives on the box: one directory per project,
+ * outside every site's release tree.
+ *
+ * Deliberately derived from the project slug ALONE. ts-cloud installs each site
+ * under `/var/www/<slug>-<site>`, so anything derived from the site name gives
+ * each site a database of its own — which is exactly how `main` and `api` ended
+ * up on separate files, with only `main` ever migrated. Two sites of one project
+ * cannot disagree about a path that does not mention which site is asking.
+ */
+export declare function projectDatabaseTarget(slug: string, relativePath: string): string;
+/**
+ * Declare the paths a Stacks server-app WRITES at runtime as ts-cloud shared
+ * paths, so they are symlinked into each release instead of dying with it.
+ *
+ * Two separate failures are closed here.
+ *
+ * **A release owns the database.** `releases/<sha>/database/stacks.sqlite` was a
+ * real file inside the release the deploy had just unpacked: `migrate` (in
+ * preStart) built a brand new empty database, the release went live against it,
+ * and every production row written since the previous deploy was gone the moment
+ * the old release was pruned — silently, with nothing in the deploy output to
+ * say so. Verified on a live box: a sentinel row was gone after the next deploy.
+ *
+ * **A site owns the database.** Each site installs under its own base, so `main`
+ * and `api` both opened `database/stacks.sqlite` relative to their OWN release
+ * — two files, only one of them ever migrated. The database is therefore pointed
+ * at a project-level target ({@link projectDatabaseTarget}) that no site's name
+ * appears in, so siblings share one file by construction. Only the site that
+ * runs `migrate` may create or seed it; the rest link at it (`seed: false`), so
+ * deploy order cannot decide whose data wins.
+ *
+ * Logs stay site-scoped — `main` and `api` are different services and their logs
+ * should not interleave.
+ *
+ * Additive: a site's own `sharedPaths` in config/cloud.ts always survive, so an
+ * app can persist its own state (upload dirs, generated assets) the same way.
+ */
+export declare function applyPersistentStatePaths(sites: Record<string, any>, slug: string): Record<string, any>;
 /**
  * Make the site model environment-aware. For a non-production environment that
  * declares a `domainPrefix` (staging → `staging`, development → `dev`), every

package/dist/commands/deploy.js

@@ -479,6 +479,74 @@ export function mergeSiteDeployEnv(sites, resolvedDeployEnv) {
     return [siteName, { ...site, env: { ...base, ...site.env || {} } }];
   }));
 }
+function looksLikeSqliteFile(value) {
+  return typeof value === "string" && /\.(?:sqlite3?|db)$/i.test(value.trim());
+}
+export function siteSqlitePath(siteEnv = {}) {
+  if (String(siteEnv.DB_CONNECTION ?? "sqlite").trim().toLowerCase() !== "sqlite")
+    return null;
+  const configured = typeof siteEnv.DB_DATABASE_PATH === "string" && siteEnv.DB_DATABASE_PATH.trim() ? siteEnv.DB_DATABASE_PATH : looksLikeSqliteFile(siteEnv.DB_DATABASE) ? siteEnv.DB_DATABASE : "database/stacks.sqlite", path = String(configured).trim().replace(/^\.\//, "");
+  if (!path || path.startsWith("/") || path.startsWith("~") || path.split("/").includes(".."))
+    return null;
+  return path;
+}
+export function tsCloudPersistentStateSupport(buildSiteDeployScript) {
+  const missing = [];
+  if (typeof buildSiteDeployScript !== "function")
+    return { ok: !1, missing: ["buildSiteDeployScript"] };
+  const target = "/var/www/probe-shared/database/probe.sqlite";
+  let script = "";
+  try {
+    script = buildSiteDeployScript({
+      siteName: "probe",
+      slug: "probe",
+      appDir: "/var/www/probe-probe",
+      artifactFetch: [],
+      releaseId: "probe",
+      execStart: "/bin/true",
+      envEntries: {},
+      port: 3000,
+      sharedPaths: [{ path: "database/probe.sqlite", target, seed: !0 }]
+    }).join(`
+`);
+  } catch {
+    return { ok: !1, missing: ["shared paths with an explicit target"] };
+  }
+  if (!(script.includes("cp -a") && script.includes("/current/")))
+    missing.push("adoption of existing state into shared/");
+  if (!script.includes(`ln -sfn ${target} `))
+    missing.push("shared paths with an explicit target");
+  return { ok: missing.length === 0, missing };
+}
+export function projectDatabaseTarget(slug, relativePath) {
+  return `/var/www/${slug}-shared/${relativePath}`;
+}
+function runsMigrations(site) {
+  return Array.isArray(site?.preStart) && site.preStart.some((cmd) => typeof cmd === "string" && /\bmigrate\b/.test(cmd));
+}
+export function applyPersistentStatePaths(sites, slug) {
+  const isServerApp = (site) => !!site && typeof site.start === "string", appSites = Object.entries(sites).filter(([, site]) => isServerApp(site)), owner = (appSites.find(([, site]) => runsMigrations(site)) ?? appSites[0])?.[0], out = {};
+  for (const [name, site] of Object.entries(sites)) {
+    if (!isServerApp(site)) {
+      out[name] = site;
+      continue;
+    }
+    const sqlite = siteSqlitePath(site.env || {}), framework = [
+      "storage/logs"
+    ];
+    if (sqlite)
+      framework.unshift({
+        path: sqlite,
+        target: projectDatabaseTarget(slug, sqlite),
+        seed: name === owner
+      });
+    const declared = Array.isArray(site.sharedPaths) ? site.sharedPaths.filter(Boolean) : [], byPath = new Map;
+    for (const entry of [...declared, ...framework])
+      byPath.set(typeof entry === "string" ? entry : entry.path, entry);
+    out[name] = { ...site, sharedPaths: [...byPath.values()] };
+  }
+  return out;
+}
 function prefixHostForEnv(host, prefix) {
   if (host.startsWith(`${prefix}.`) || host.startsWith(`www.${prefix}.`))
     return host;
@@ -546,7 +614,13 @@ async function deployToHetzner(tsCloudConfig, deployEnv, options) {
     log.info("Generate one with:  ssh-keygen -t ed25519");
     process.exit(ExitCode.FatalError);
   }
-  const { createCloudDriver, deployAllComputeSites, ensureManagementDashboard, resolveSiteKind } = await loadTsCloudDeployApi();
+  const { createCloudDriver, deployAllComputeSites, ensureManagementDashboard, resolveSiteKind, buildSiteDeployScript } = await loadTsCloudDeployApi(), support = tsCloudPersistentStateSupport(buildSiteDeployScript);
+  if (!support.ok) {
+    log.error("This ts-cloud cannot keep your database across deploys, and deploying anyway would destroy it.");
+    log.error(`Missing: ${support.missing.join(", ")}.`);
+    log.error("Upgrade @stacksjs/ts-cloud (bun update @stacksjs/ts-cloud), or point TS_CLOUD_MODULE at a build that has it.");
+    process.exit(ExitCode.FatalError);
+  }
   try {
     await runHetznerDeploy({ tsCloudConfig, environment, verbose, docker: options.docker === !0, createCloudDriver, deployAllComputeSites, ensureManagementDashboard, resolveSiteKind, onlySite: options.site || void 0, persistedAttachBox });
   } catch (err) {
@@ -830,7 +904,10 @@ async function runHetznerDeploy(args) {
     ".env.local",
     ".env.keys",
     ".env.production.bak",
-    ".env.production.plain"
+    ".env.production.plain",
+    "*.sqlite",
+    "*.sqlite-wal",
+    "*.sqlite-shm"
   ];
   if (onlySite && !sites[onlySite]) {
     log.error(`--site '${onlySite}' is not a configured site. Available: ${Object.keys(sites).join(", ")}`);
@@ -862,7 +939,7 @@ async function runHetznerDeploy(args) {
   }
   if (docker)
     await buildContainerImageWithPantry({ slug, sites, verbose });
-  const resolvedDeployEnv = await resolveDeployEnvValues(environment, tsCloudConfig), sitesWithResolvedEnv = mergeSiteDeployEnv(sites, resolvedDeployEnv);
+  const resolvedDeployEnv = await resolveDeployEnvValues(environment, tsCloudConfig), sitesWithResolvedEnv = applyPersistentStatePaths(mergeSiteDeployEnv(sites, resolvedDeployEnv), slug);
   for (const [envKey, envValue] of Object.entries(resolvedDeployEnv))
     if (process.env[envKey] === void 0)
       process.env[envKey] = envValue;

package/dist/commands/generate.js

@@ -60,6 +60,20 @@ export function generate(buddy) {
       log.warn(`[generate:db-types] ${e.file}: ${e.error}`);
     log.info(`[generate:db-types] resolved ${result.tables.length} table(s)`);
   });
+  buddy.command("generate:vschema", "Derive a Vitess VSchema from your models (writes database/vschema.json)").option("--dry-run", "Print the VSchema without writing it", { default: !1 }).option("--out [path]", "Where to write the VSchema", { default: "database/vschema.json" }).action(async (options) => {
+    const { generateVSchema } = await import("@stacksjs/actions"), result = await generateVSchema({ dryRun: options.dryRun, out: options.out });
+    if (!result.ok) {
+      console.error(`
+\u274C ${result.error}
+`);
+      process.exit(ExitCode.FatalError);
+    }
+    console.log(result.report);
+    if (options.dryRun)
+      console.log(JSON.stringify(result.vschema, null, 2));
+    else
+      log.success(`Wrote ${result.path} (${result.tableCount} tables)`);
+  });
   buddy.command("generate:entries", descriptions.entries).option("-p, --project [project]", descriptions.project, { default: !1 }).option("--verbose", descriptions.verbose, { default: !1 }).action(async (options) => {
     log.debug("Running `buddy generate:entries` ...", options);
     await generateLibEntries(options);

package/dist/commands/migrate.js

@@ -6,7 +6,7 @@ import { hasTTY, isCI } from "@stacksjs/env";
 import { appPath, frameworkPath, frameworkRuntimePath, projectPath } from "@stacksjs/path";
 import { ExitCode } from "@stacksjs/types";
 import { preflightDatabase } from "../database-preflight";
-import { DIALECT_OVERRIDE_ENV, auditMigrationCorpus, formatMigrationDialectError, stripSqlNoise } from "@stacksjs/database";
+import { DDL_CONSTRAINT_OVERRIDE_ENV, DIALECT_OVERRIDE_ENV, auditDdlConstraints, auditMigrationCorpus, dialectCapabilities, formatDdlConstraintError, formatMigrationDialectError, stripSqlNoise } from "@stacksjs/database";
 let _runAction;
 async function runAction(...args) {
   if (!_runAction)
@@ -85,15 +85,21 @@ function validateModelsExist() {
   return { valid: !0 };
 }
 function validateMigrationDialect() {
-  if (process.env[DIALECT_OVERRIDE_ENV] === "1")
-    return { valid: !0 };
-  const driver = String(process.env.DB_CONNECTION || "sqlite").toLowerCase(), target = driver === "singlestore" ? "mysql" : driver;
-  if (target !== "sqlite" && target !== "postgres" && target !== "mysql")
-    return { valid: !0 };
-  const dir = projectPath("database/migrations"), audit = auditMigrationCorpus({ dir, target });
-  if (audit.empty || audit.incompatible.length === 0)
-    return { valid: !0 };
-  return { valid: !1, error: formatMigrationDialectError(audit, target, "database/migrations") };
+  const driver = String(process.env.DB_CONNECTION || "sqlite").toLowerCase(), dir = projectPath("database/migrations");
+  if (process.env[DIALECT_OVERRIDE_ENV] !== "1") {
+    const caps = dialectCapabilities(driver), target = caps.wire === "mysql" ? "mysql" : caps.wire === "postgres" ? "postgres" : "sqlite";
+    if (driver === "sqlite" || driver === "postgres" || caps.wire === "mysql") {
+      const audit = auditMigrationCorpus({ dir, target });
+      if (!audit.empty && audit.incompatible.length > 0)
+        return { valid: !1, error: formatMigrationDialectError(audit, target, "database/migrations") };
+    }
+  }
+  if (process.env[DDL_CONSTRAINT_OVERRIDE_ENV] !== "1") {
+    const constraints = auditDdlConstraints({ dir, dialect: driver });
+    if (!constraints.empty && constraints.violations.length > 0)
+      return { valid: !1, error: formatDdlConstraintError(constraints, driver, "database/migrations") };
+  }
+  return { valid: !0 };
 }
 async function reportMissingForeignKeys() {
   try {
@@ -289,14 +295,20 @@ export function migrate(buddy) {
       log.error("Model migrations failed \u2014 applying notification/RBAC table guarantees before exiting.");
     if (options.auth !== !1)
       try {
-        const { migrateNotificationTables, migrateRbacTables } = await import("@stacksjs/database"), notifResult = await migrateNotificationTables({ verbose: options.verbose });
+        const { ensureUtcDatetimeColumns, migrateNotificationTables, migrateRbacTables, migrateTraitTables } = await import("@stacksjs/database"), notifResult = await migrateNotificationTables({ verbose: options.verbose });
         if (!notifResult.success)
           log.error(`Failed to migrate notification tables: ${notifResult.error}`);
         const rbacResult = await migrateRbacTables({ verbose: options.verbose });
         if (!rbacResult.success)
           log.error(`Failed to migrate RBAC tables: ${rbacResult.error}`);
+        const traitResult = await migrateTraitTables({ verbose: options.verbose });
+        if (!traitResult.success)
+          log.error(`Failed to migrate polymorphic trait tables: ${traitResult.error}`);
+        const datetimeResult = await ensureUtcDatetimeColumns({ verbose: options.verbose });
+        if (!datetimeResult.success)
+          log.error(`Failed to convert TIMESTAMP columns to DATETIME: ${datetimeResult.error}`);
       } catch (error) {
-        log.error("Failed to migrate notification/RBAC tables:", error);
+        log.error("Failed to migrate notification/RBAC/trait tables:", error);
       }
     if (result.isErr) {
       await outro("While running the migrate command, there was an issue", { startTime: perf, useSeconds: !0 }, result.error);
@@ -371,7 +383,7 @@ export function migrate(buddy) {
     if (options.auth !== !1) {
       log.debug("Migrating auth tables...");
       try {
-        const { migrateAuthTables, migrateNotificationTables, migrateRbacTables } = await import("@stacksjs/database"), authResult = await migrateAuthTables({ verbose: options.verbose });
+        const { migrateAuthTables, migrateNotificationTables, migrateRbacTables, migrateTraitTables } = await import("@stacksjs/database"), authResult = await migrateAuthTables({ verbose: options.verbose });
         if (!authResult.success)
           log.error(`Failed to migrate auth tables: ${authResult.error}`);
         const notifResult = await migrateNotificationTables({ verbose: options.verbose });
@@ -380,8 +392,11 @@ export function migrate(buddy) {
         const rbacResult = await migrateRbacTables({ verbose: options.verbose });
         if (!rbacResult.success)
           log.error(`Failed to migrate RBAC tables: ${rbacResult.error}`);
+        const traitResult = await migrateTraitTables({ verbose: options.verbose });
+        if (!traitResult.success)
+          log.error(`Failed to migrate polymorphic trait tables: ${traitResult.error}`);
       } catch (error) {
-        log.error("Failed to migrate auth/notification/RBAC tables:", error);
+        log.error("Failed to migrate auth/notification/RBAC/trait tables:", error);
       }
     }
     try {

package/dist/production-server.d.ts

@@ -1,35 +1 @@
-/**
- * Resolve the project's includes directory.
- *
- * A configured `config/stx.ts#partialsDir` wins outright. The convention list
- * below is only a fallback for apps that never set one, and it cannot stand in
- * for the config: the candidates are probed for existence in order, so an app
- * that keeps its includes in `resources/components` but also has an unrelated
- * `resources/partials` directory silently resolved to the wrong one and every
- * `@include` failed with ENOENT at runtime.
- *
- * The configured value is relative to the stx root (`resources`), matching how
- * stx itself reads it, but an app-root-relative path is accepted too so either
- * spelling resolves.
- */
-export declare function resolveUserPartialsPath(cwd?: unknown, configuredDir?: string): string | undefined;
-/**
- * Read `partialsDir` off the app's stx config. Failure is non-fatal: without
- * it {@link resolveUserPartialsPath} falls back to the conventions.
- */
-export declare function loadStxPartialsDir(cwd?: unknown): Promise<string | undefined>;
-/**` proxy target, or `null` when it cannot be
- * known safely.
- *
- * `API_URL` and `PORT_API` are explicit operator intent and always win. The
- * framework-wide `ports.api` default is only trusted *outside* deployed
- * environments: locally one app owns the machine, so `127.0.0.1:3008` really is
- * its own API. On a deployed box that assumption does not hold — ts-cloud runs
- * many SSR sites side by side, each on its own port, and an unconfigured
- * default resolves to whichever tenant happens to own it.
- *
- * Returning `null` makes the caller answer 502. That is the safe failure: the
- * alternative is proxying authenticated requests into another app's process.
- */
-export declare function resolveApiBase(configuredPort?: number, env?: NodeJS.ProcessEnv): string | null;
-export declare function startProductionServer(options?: { port?: string | number, verbose?: boolean }): Promise<void>;
+export {};

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/buddy",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.255",
+  "version": "0.70.257",
   "description": "Meet Buddy. The Stacks runtime.",
   "author": "Chris Breuer",
   "contributors": [
@@ -88,53 +88,53 @@
     "prepublishOnly": "bun run build"
   },
   "dependencies": {
-    "@stacksjs/actions": "^0.70.255",
-    "@stacksjs/ai": "^0.70.255",
-    "@stacksjs/alias": "^0.70.255",
-    "@stacksjs/arrays": "^0.70.255",
-    "@stacksjs/auth": "^0.70.255",
-    "@stacksjs/build": "^0.70.255",
-    "@stacksjs/cache": "^0.70.255",
-    "@stacksjs/cli": "^0.70.255",
+    "@stacksjs/actions": "^0.70.257",
+    "@stacksjs/ai": "^0.70.257",
+    "@stacksjs/alias": "^0.70.257",
+    "@stacksjs/arrays": "^0.70.257",
+    "@stacksjs/auth": "^0.70.257",
+    "@stacksjs/build": "^0.70.257",
+    "@stacksjs/cache": "^0.70.257",
+    "@stacksjs/cli": "^0.70.257",
     "@stacksjs/clapp": "^0.2.12",
-    "@stacksjs/cloud": "^0.70.255",
-    "@stacksjs/collections": "^0.70.255",
-    "@stacksjs/config": "^0.70.255",
-    "@stacksjs/database": "^0.70.255",
-    "@stacksjs/desktop-build": "^0.70.255",
-    "@stacksjs/dns": "^0.70.255",
-    "@stacksjs/email": "^0.70.255",
-    "@stacksjs/enums": "^0.70.255",
-    "@stacksjs/error-handling": "^0.70.255",
-    "@stacksjs/events": "^0.70.255",
-    "@stacksjs/git": "^0.70.255",
+    "@stacksjs/cloud": "^0.70.257",
+    "@stacksjs/collections": "^0.70.257",
+    "@stacksjs/config": "^0.70.257",
+    "@stacksjs/database": "^0.70.257",
+    "@stacksjs/desktop-build": "^0.70.257",
+    "@stacksjs/dns": "^0.70.257",
+    "@stacksjs/email": "^0.70.257",
+    "@stacksjs/enums": "^0.70.257",
+    "@stacksjs/error-handling": "^0.70.257",
+    "@stacksjs/events": "^0.70.257",
+    "@stacksjs/git": "^0.70.257",
     "@stacksjs/gitit": "^0.2.5",
-    "@stacksjs/health": "^0.70.255",
+    "@stacksjs/health": "^0.70.257",
     "@stacksjs/dnsx": "^0.2.3",
     "@stacksjs/httx": "^0.1.10",
-    "@stacksjs/image": "^0.70.255",
-    "@stacksjs/lint": "^0.70.255",
-    "@stacksjs/logging": "^0.70.255",
-    "@stacksjs/notifications": "^0.70.255",
-    "@stacksjs/objects": "^0.70.255",
-    "@stacksjs/orm": "^0.70.255",
-    "@stacksjs/path": "^0.70.255",
-    "@stacksjs/skills": "^0.70.255",
-    "@stacksjs/payments": "^0.70.255",
-    "@stacksjs/realtime": "^0.70.255",
-    "@stacksjs/router": "^0.70.255",
+    "@stacksjs/image": "^0.70.257",
+    "@stacksjs/lint": "^0.70.257",
+    "@stacksjs/logging": "^0.70.257",
+    "@stacksjs/notifications": "^0.70.257",
+    "@stacksjs/objects": "^0.70.257",
+    "@stacksjs/orm": "^0.70.257",
+    "@stacksjs/path": "^0.70.257",
+    "@stacksjs/skills": "^0.70.257",
+    "@stacksjs/payments": "^0.70.257",
+    "@stacksjs/realtime": "^0.70.257",
+    "@stacksjs/router": "^0.70.257",
     "@stacksjs/rpx": "^0.11.42",
-    "@stacksjs/search-engine": "^0.70.255",
-    "@stacksjs/security": "^0.70.255",
-    "@stacksjs/server": "^0.70.255",
-    "@stacksjs/storage": "^0.70.255",
-    "@stacksjs/strings": "^0.70.255",
-    "@stacksjs/testing": "^0.70.255",
-    "@stacksjs/tunnel": "^0.70.255",
-    "@stacksjs/types": "^0.70.255",
-    "@stacksjs/ui": "^0.70.255",
-    "@stacksjs/utils": "^0.70.255",
-    "@stacksjs/validation": "^0.70.255",
+    "@stacksjs/search-engine": "^0.70.257",
+    "@stacksjs/security": "^0.70.257",
+    "@stacksjs/server": "^0.70.257",
+    "@stacksjs/storage": "^0.70.257",
+    "@stacksjs/strings": "^0.70.257",
+    "@stacksjs/testing": "^0.70.257",
+    "@stacksjs/tunnel": "^0.70.257",
+    "@stacksjs/types": "^0.70.257",
+    "@stacksjs/ui": "^0.70.257",
+    "@stacksjs/utils": "^0.70.257",
+    "@stacksjs/validation": "^0.70.257",
     "@stacksjs/ts-cloud": "^0.7.92",
     "ajv": "^8.20.0",
     "ajv-formats": "^3.0.1",