@stacksjs/database 0.70.228 → 0.70.230

package/dist/relation-columns.js

@@ -0,0 +1,66 @@
+import { getTableName } from "@stacksjs/orm";
+import { path } from "@stacksjs/path";
+import { fs } from "@stacksjs/storage";
+function snakeCase(str) {
+  return str.replace(/([A-Z]+)([A-Z][a-z])/g, "$1_$2").replace(/([a-z\d])([A-Z])/g, "$1_$2").replace(/(\d)([A-Za-z])/g, "$1_$2").toLowerCase();
+}
+export function belongsToColumn(entry) {
+  if (typeof entry === "string")
+    return entry.length > 0 ? `${snakeCase(entry)}_id` : null;
+  if (entry && typeof entry === "object") {
+    const relation = entry;
+    if (typeof relation.foreignKey === "string" && relation.foreignKey.length > 0)
+      return relation.foreignKey;
+    if (typeof relation.model === "string" && relation.model.length > 0)
+      return `${snakeCase(relation.model)}_id`;
+  }
+  return null;
+}
+export function belongsToColumnsOf(model) {
+  const declared = model.belongsTo;
+  if (!declared)
+    return [];
+  const entries = Array.isArray(declared) ? declared : Object.entries(declared).map(([model, value]) => value && typeof value === "object" ? { model, ...value } : model), columns = [];
+  for (const entry of entries) {
+    const column = belongsToColumn(entry);
+    if (column)
+      columns.push(column);
+  }
+  return columns;
+}
+async function loadModelsFrom(dir) {
+  const out = [];
+  if (!fs.existsSync(dir))
+    return out;
+  for (const entry of fs.readdirSync(dir, { withFileTypes: !0 })) {
+    const fullPath = path.join(dir, entry.name);
+    if (entry.isDirectory()) {
+      out.push(...await loadModelsFrom(fullPath));
+      continue;
+    }
+    if (!entry.name.endsWith(".ts"))
+      continue;
+    if (entry.name.startsWith("_") || entry.name.startsWith("index"))
+      continue;
+    try {
+      const imported = (await import(fullPath)).default;
+      if (imported?.name || imported?.table)
+        out.push({ filePath: fullPath, model: imported });
+    } catch {}
+  }
+  return out;
+}
+export async function findRelationForeignKeys() {
+  const dirs = [path.userModelsPath(), path.frameworkPath("defaults/app/Models")], byTable = new Map;
+  for (const dir of dirs)
+    for (const { filePath, model } of await loadModelsFrom(dir)) {
+      const columns = belongsToColumnsOf(model);
+      if (columns.length === 0)
+        continue;
+      const table = getTableName(model, filePath), existing = byTable.get(table) ?? new Set;
+      for (const column of columns)
+        existing.add(column);
+      byTable.set(table, existing);
+    }
+  return byTable;
+}

package/dist/seeder.d.ts

@@ -1,4 +1,8 @@
 import type { Attribute, Model } from '@stacksjs/types';
+/**
+ * Returns the path to the framework default models directory
+ */
+export declare function defaultModelsPath(subpath?: string): string;
 /** Test whether a model holds accounts rather than fixtures. */
 export declare function isAccountModel(name: string): boolean;
 /**
@@ -7,6 +11,16 @@ export declare function isAccountModel(name: string): boolean;
  * list stays a single source of truth.
  */
 export declare function isProtectedModel(name: string): boolean;
+/** Record the table names of the models about to be seeded. */
+export declare function registerModelTables(models: { name: string, table: string }[]): void;
+/**
+ * The table a parent model lives in.
+ *
+ * Falls back to the old guess for a parent that is not itself being seeded
+ * (a framework model with no `useSeeder`, say), which is still right for the
+ * regular plurals that make up most of them.
+ */
+export declare function parentTable(parent: string): string;
 /**
  * Choose one consistent set of parent ids per record.
  *
@@ -15,6 +29,16 @@ export declare function isProtectedModel(name: string): boolean;
  * foreign keys agree with one another.
  */
 export declare function chooseRelations(pools: { column: string, rows: Record<string, unknown>[] }[], count: number): Record<string, unknown>[];
+/**
+ * The parents a model declares, with the column each one is reached through.
+ *
+ * The column defaults to `<model>_id`, which is what most relations look like.
+ * An entry may override it with `foreignKey`, and doing so is not a niceness:
+ * a model that belongs to `User` twice — an author and a reviewer — has no
+ * `user_id` at all, so under the derived name neither key was ever filled and
+ * both fell back to whatever the factory invented.
+ */
+export declare function parentRelations(model: SeederModel): ParentRelation[];
 /**
  * Seeds the database from your models.
  *
@@ -129,6 +153,11 @@ export declare interface SeederModel {
   model: Model
   filePath: string
 }
+/** A parent a model belongs to, and the column that points at it. */
+export declare interface ParentRelation {
+  model: string
+  column: string
+}
 // Legacy exports for backwards compatibility
 export { seed as runSeeders };
 export { freshSeed as freshWithSeed };

package/dist/seeder.js

@@ -4,7 +4,7 @@ import { faker } from "@stacksjs/faker";
 import { path } from "@stacksjs/path";
 import { hashMake } from "@stacksjs/security";
 import { fs } from "@stacksjs/storage";
-function defaultModelsPath(subpath) {
+export function defaultModelsPath(subpath) {
   return path.frameworkPath(`defaults/app/Models/${subpath || ""}`);
 }
 export const PROTECTED_MODELS = Object.freeze([
@@ -153,18 +153,27 @@ async function existingRows(table) {
     return [];
   }
 }
+const modelTables = new Map;
+export function registerModelTables(models) {
+  modelTables.clear();
+  for (const model of models)
+    modelTables.set(model.name, model.table);
+}
+export function parentTable(parent) {
+  return modelTables.get(parent) ?? `${snakeCase(parent)}s`;
+}
 async function relationColumns(model, options = {}) {
-  const parents = parentModels(model);
+  const parents = parentRelations(model);
   if (parents.length === 0)
     return [];
   const pools = [];
-  for (const parent of parents) {
-    const column = `${snakeCase(parent)}_id`;
+  for (const relation of parents) {
+    const { model: parent, column } = relation;
     if (model.attributes[parent])
       continue;
     if (isAccountModel(parent) && !options.allowProtected)
       continue;
-    const rows = await existingRows(`${snakeCase(parent)}s`);
+    const rows = await existingRows(parentTable(parent));
     if (rows.length > 0)
       pools.push({ column, rows });
   }
@@ -273,13 +282,23 @@ async function seedModel(model, options) {
     };
   }
 }
+export function parentRelations(model) {
+  const belongsTo = model.model.belongsTo, read = (entry) => {
+    if (typeof entry === "string")
+      return entry ? { model: entry, column: `${snakeCase(entry)}_id` } : null;
+    if (entry && typeof entry === "object") {
+      const name = String(entry.model ?? "");
+      if (!name)
+        return null;
+      const key = entry.foreignKey;
+      return { model: name, column: key || `${snakeCase(name)}_id` };
+    }
+    return null;
+  };
+  return (Array.isArray(belongsTo) ? belongsTo : belongsTo && typeof belongsTo === "object" ? Object.values(belongsTo) : []).map(read).filter((relation) => relation !== null);
+}
 function parentModels(model) {
-  const belongsTo = model.model.belongsTo;
-  if (Array.isArray(belongsTo))
-    return belongsTo.map((entry) => typeof entry === "string" ? entry : String(entry?.model ?? "")).filter(Boolean);
-  if (belongsTo && typeof belongsTo === "object")
-    return Object.values(belongsTo).map((value) => String(value?.model ?? value)).filter(Boolean);
-  return [];
+  return parentRelations(model).map((relation) => relation.model);
 }
 async function clearTables(models, verbose) {
   for (const model of [...models].reverse())
@@ -322,6 +341,7 @@ export async function seed(config = {}) {
     log.info(`Default models directory: ${defaultModelsPath()}`);
   }
   let models = await loadAllModels(modelsDir, verbose, config.includeDefaults ?? !1);
+  registerModelTables(models);
   if (models.length === 0) {
     log.warn("No seedable models found in defaults or user directories");
     return {

package/dist/utils.d.ts

@@ -1,7 +1,9 @@
 import { createQueryBuilder, setConfig } from '@stacksjs/query-builder';
+import type { QueryHooks } from '@stacksjs/query-builder';
 export declare function acquireDbConfigLock(): Promise<() => void>;
 // Function to initialize the config when it's available
 export declare function initializeDbConfig(config: any): void;
+export declare function createDatabaseQueryHooks(dispatch: (event: DatabaseQueryLogEvent) => void | Promise<void>): QueryHooks;
 export declare function ensureDatabaseConfigLoaded(): Promise<void>;
 declare function getDb(): ReturnType<typeof createQueryBuilder>;
 /**
@@ -17,11 +19,33 @@ declare function getDb(): ReturnType<typeof createQueryBuilder>;
  * different call sites, which is a sign the value wants one home.
  */
 export declare const QB_SNAPSHOT_DIR: 'storage/framework/database';
+/**
+ * Process-wide query-builder soft-delete filtering must stay disabled.
+ *
+ * The raw query builder has no model definition, so it cannot know whether
+ * the selected table carries the `useSoftDeletes` trait or even has a
+ * `deleted_at` column. ModelQueryBuilder applies the trait-aware scope, and
+ * the generated REST routes apply it from the model definition. Enabling
+ * this global filter would incorrectly scope every raw table query.
+ */
+export declare const RAW_QUERY_SOFT_DELETE_CONFIG: {
+  enabled: false;
+  column: 'deleted_at';
+  defaultFilter: true
+};
 /**
  * Lazy proxy for the query builder - connection is only made when first used.
  * This is the main entry point for database operations.
  */
 export declare const db: Proxy;
+export declare interface DatabaseQueryLogEvent {
+  query: {
+    sql: string
+    parameters?: unknown[]
+  }
+  queryDurationMillis: number
+  error?: unknown
+}
 /**
  * Fluent chain returned by entry-point methods like `selectFrom`/`updateTable`.
  *

package/dist/utils.js

@@ -1,5 +1,5 @@
 import { AsyncLocalStorage } from "node:async_hooks";
-import { createQueryBuilder, setConfig } from "@stacksjs/query-builder";
+import { createQueryBuilder, registerPersistentQueryHooks, setConfig } from "@stacksjs/query-builder";
 import { env as envVars } from "@stacksjs/env";
 import { getConnectionDefaults } from "./defaults";
 import { aggregateFunctions } from "./types";
@@ -87,7 +87,39 @@ function getDbConfig() {
   }
   return { database: ":memory:" };
 }
-export const QB_SNAPSHOT_DIR = "storage/framework/database";
+export const QB_SNAPSHOT_DIR = "storage/framework/database", RAW_QUERY_SOFT_DELETE_CONFIG = {
+  enabled: !1,
+  column: "deleted_at",
+  defaultFilter: !0
+};
+export function createDatabaseQueryHooks(dispatch) {
+  function forward(event) {
+    try {
+      Promise.resolve(dispatch(event)).catch(() => {});
+    } catch {}
+  }
+  return {
+    onQueryEnd: (event) => forward({
+      query: {
+        sql: event.sql,
+        parameters: event.params
+      },
+      queryDurationMillis: event.durationMs
+    }),
+    onQueryError: (event) => forward({
+      query: {
+        sql: event.sql,
+        parameters: event.params
+      },
+      queryDurationMillis: event.durationMs,
+      error: event.error
+    })
+  };
+}
+function forwardDatabaseQuery(event) {
+  import("./query-logger").then(({ logQuery }) => logQuery(event)).catch(() => {});
+}
+registerPersistentQueryHooks(createDatabaseQueryHooks(forwardDatabaseQuery));
 function updateQueryBuilderConfig() {
   const dialect = getDialect(), dbConfigForQb = getDbConfig();
   setConfig({
@@ -100,11 +132,7 @@ function updateQueryBuilderConfig() {
       updatedAt: "updated_at",
       defaultOrderColumn: "created_at"
     },
-    softDeletes: {
-      enabled: !0,
-      column: "deleted_at",
-      defaultFilter: !0
-    }
+    softDeletes: RAW_QUERY_SOFT_DELETE_CONFIG
   });
 }
 updateQueryBuilderConfig();

package/package.json

@@ -2,7 +2,7 @@
   "name": "@stacksjs/database",
   "type": "module",
   "sideEffects": false,
-  "version": "0.70.228",
+  "version": "0.70.230",
   "description": "The Stacks database integration.",
   "author": "Chris Breuer",
   "contributors": [
@@ -60,15 +60,15 @@
     "dynamodb-tooling": "^0.3.2"
   },
   "devDependencies": {
-    "@stacksjs/cli": "0.70.228",
-    "@stacksjs/config": "0.70.228",
-    "@stacksjs/logging": "0.70.228",
-    "@stacksjs/router": "0.70.228",
+    "@stacksjs/cli": "0.70.230",
+    "@stacksjs/config": "0.70.230",
+    "@stacksjs/logging": "0.70.230",
+    "@stacksjs/router": "0.70.230",
     "better-dx": "^0.2.17",
-    "@stacksjs/path": "0.70.228",
-    "@stacksjs/query-builder": "0.70.228",
-    "@stacksjs/storage": "0.70.228",
-    "@stacksjs/strings": "0.70.228",
-    "@stacksjs/utils": "0.70.228"
+    "@stacksjs/path": "0.70.230",
+    "@stacksjs/query-builder": "0.70.230",
+    "@stacksjs/storage": "0.70.230",
+    "@stacksjs/strings": "0.70.230",
+    "@stacksjs/utils": "0.70.230"
   }
 }