@everystack/cli 0.4.99 → 0.4.102

package/src/cli/schema-source.ts

@@ -16,17 +16,28 @@
  *  - Cross-schema FKs (e.g. `profiles.id → auth.users.id`) are OMITTED — the model
  *    can't express a reference to a non-Model table, so neither can the emitter.
  *  - `relationName` strings are synthesized deterministically (the `Relation` type
- *    carries no name); only the pairing of a belongsTo with its inverse hasMany
- *    matters, which the synthesis guarantees.
+ *    carries no name); only the pairing of a belongsTo with its inverse hasMany or
+ *    hasOne matters, which the synthesis guarantees. A hasOne renders as `one(target)`.
  *
  * Pure and deterministic: imports sorted, declarations in model order, relation
  * keys in declared order — re-running on the same models is byte-identical.
  *
- * Input is a `@everystack/model` ModelDescriptor (type-only — no runtime dep).
+ * Input is a `@everystack/model` ModelDescriptor. The one runtime import is
+ * `relationDeleteActions`: a parent's hasMany `dependent` sets a child FK's onDelete, derived
+ * from the set passed in (pure; no spec is written).
  */
 
-import type { ModelDescriptor, FieldSpec, DerivedDescriptor, ViewDescriptor, MaterializedViewDescriptor } from '@everystack/model';
+import { relationDeleteActions, type ModelDescriptor, type ReferentialAction, type Relation, type FieldSpec, type DerivedDescriptor, type ViewDescriptor, type MaterializedViewDescriptor } from '@everystack/model';
 import { parseQualified } from './derived-source';
+import { commentText } from './ts-template';
+
+/**
+ * Drizzle relations carry no order, limit or filter, so `db.query.x.findMany({ with })` ignores a
+ * relation's display options and a hasOne returns any one matching row. Each such relation gets
+ * one note above it; a relation that declares none gets nothing (D8: byte-identical).
+ */
+const DISPLAY_NOTE = 'display options (where/limit/orderBy) are not applied by drizzle `with`: filter in the query';
+const HAS_ONE_NOTE = 'hasOne: drizzle `with` returns any one matching row (orderBy and where are not applied): order and filter in the query';
 
 /** `author_id` is the SQL identifier; `authorId` the field key. The single snake-case rule. */
 function toSnakeCase(name: string): string {
@@ -182,7 +193,7 @@ function columnModifiers(
   spec: FieldSpec,
   isComposite: boolean,
   modelsByDescriptor: Map<ModelDescriptor, { camel: string }>,
-  ctx: { builder?: string; self?: ModelDescriptor; usedTypes?: Set<string> } = {},
+  ctx: { builder?: string; self?: ModelDescriptor; usedTypes?: Set<string>; onDelete?: ReferentialAction } = {},
 ): string {
   let s = '';
   if (spec.isArray) s += '.array()';
@@ -208,7 +219,9 @@ function columnModifiers(
     if (entry) {
       const parentPk = primaryKeyKey(target);
       const opts: string[] = [];
-      if (spec.onDelete) opts.push(`onDelete: ${strLiteral(spec.onDelete)}`);
+      // A parent's hasMany `dependent` (ctx.onDelete, derived from the set) or the child's own.
+      const onDelete = ctx.onDelete ?? spec.onDelete;
+      if (onDelete) opts.push(`onDelete: ${strLiteral(onDelete)}`);
       if (spec.onUpdate) opts.push(`onUpdate: ${strLiteral(spec.onUpdate)}`);
       const optsText = opts.length ? `, { ${opts.join(', ')} }` : '';
       // A SELF-referential FK needs drizzle's documented return-type annotation. Without it
@@ -302,7 +315,7 @@ function planRelationNames(models: ModelDescriptor[]): RelationNaming {
 /** The `relationName: '…'` fragment for a relation, or '' when the pair is unambiguous. */
 function relationNameFragment(
   model: ModelDescriptor,
-  rel: { kind: 'belongsTo' | 'hasMany'; column: string; target: () => ModelDescriptor },
+  rel: Pick<Relation, 'kind' | 'column' | 'target'>,
   naming: RelationNaming,
 ): string {
   const other = rel.target().table;
@@ -348,6 +361,8 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
   // generated schema. (The migration generator still emits its SQL + authz.) The
   // command and the drift guard both call this, so filtering here keeps them in sync.
   const models = allModels.filter((m) => !m.private);
+  // Over the whole set, private models included: a hasMany `dependent` sets a child FK's ON DELETE.
+  const dependents = relationDeleteActions(allModels);
   const derivedRelations = typedRelations(_opts.derived ?? []);
 
   const modelsByDescriptor = new Map<ModelDescriptor, { camel: string }>();
@@ -396,7 +411,7 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
       const { call, builder: pgBuilder } = baseColumnSource(toSnakeCase(key), spec);
       pgCoreBuilders.add(pgBuilder);
       if (spec.defaultKind === 'sql') pgCoreBuilders.add('sql'); // imported from 'drizzle-orm', handled below
-      const mods = columnModifiers(spec, isComposite, modelsByDescriptor, { builder: pgBuilder, self: model, usedTypes: pgCoreTypes });
+      const mods = columnModifiers(spec, isComposite, modelsByDescriptor, { builder: pgBuilder, self: model, usedTypes: pgCoreTypes, onDelete: dependents.get(model)?.get(key) });
       if (spec.isDeprecated) {
         // The contract phase (decision 13): the column stays in the database and
         // stays readable; the strikethrough warns new code away at author time.
@@ -452,7 +467,7 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
     if (relEntries.length === 0) continue;
     const camel = modelCamel(model);
 
-    const usesOne = relEntries.some(([, r]) => r.kind === 'belongsTo');
+    const usesOne = relEntries.some(([, r]) => r.kind === 'belongsTo' || r.kind === 'hasOne');
     const usesMany = relEntries.some(([, r]) => r.kind === 'hasMany');
     const helpers = [usesOne ? 'one' : null, usesMany ? 'many' : null].filter(Boolean).join(', ');
 
@@ -461,6 +476,8 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
       const target = rel.target();
       const targetCamel = modelCamel(target);
       const nameFrag = relationNameFragment(model, rel, relationNaming);
+      if (rel.kind === 'hasOne') lines.push(`  // ${commentText(HAS_ONE_NOTE)}`);
+      else if (rel.orderBy !== undefined || rel.limit !== undefined || rel.where !== undefined) lines.push(`  // ${commentText(DISPLAY_NOTE)}`);
       if (rel.kind === 'belongsTo') {
         // belongsTo(() => Target, column, references?) -> one(...)
         const thisCol = rel.column; // FK FIELD KEY on this model
@@ -468,6 +485,20 @@ export function compileDrizzleSource(allModels: ModelDescriptor[], _opts: Compil
         lines.push(
           `  ${key}: one(${targetCamel}, { fields: [${camel}.${thisCol}], references: [${targetCamel}.${targetPk}]${nameFrag} }),`,
         );
+      } else if (rel.kind === 'hasOne') {
+        // hasOne(() => Target, column) -> one(Target): the inverse of the target's belongsTo, as
+        // many(Target) is for a hasMany. Drizzle takes fields/references from that belongsTo, and
+        // a one() with no fields is typed nullable (a parent may have no such row). Its orderBy
+        // and where are display options with no drizzle form; F10 applies them per query.
+        // Drizzle's one() config requires fields, so a relationName alone is not an option: a
+        // pair joined by more than one FK is refused by name rather than emitted broken.
+        if (nameFrag) {
+          const at = model.schema === 'public' ? model.table : `${model.schema}.${model.table}`;
+          throw new Error(
+            `model '${at}': relation '${key}': a hasOne between two tables joined by more than one foreign key is not supported yet (${model.table} and ${target.table})`,
+          );
+        }
+        lines.push(`  ${key}: one(${targetCamel}),`);
       } else {
         // hasMany(() => Target, column, references?) -> many(...)
         if (nameFrag) {

package/src/cli/schema-swap.ts

@@ -30,7 +30,7 @@
  * so the swap is a pointer flip, never a recompute.
  */
 
-import type { ModelDescriptor } from '@everystack/model';
+import { relationDeleteActions, type ModelDescriptor } from '@everystack/model';
 import { modelForeignKeys, qualifiedTable } from './schema-compile';
 import { compileTableContract } from './authz-compile';
 import { emitSwapAuthzSql } from './authz-reconcile';
@@ -73,10 +73,11 @@ export interface CrossSchemaFk {
  */
 export function crossSchemaForeignKeys(models: ModelDescriptor[], targetSchema: string): CrossSchemaFk[] {
   const out: CrossSchemaFk[] = [];
+  const dependents = relationDeleteActions(models);
   for (const model of models) {
     if ((model.schema || 'public') === targetSchema) continue; // internal edge, not external
     const from = qualifiedTable(model);
-    for (const fk of modelForeignKeys(model)) {
+    for (const fk of modelForeignKeys(model, dependents)) {
       if (schemaOf(fk.refTable) !== targetSchema) continue; // not pointing into the swapped schema
       const cols = fk.columns.map((c) => `"${c}"`).join(', ');
       const refCols = fk.refColumns.map((c) => `"${c}"`).join(', ');

package/src/cli/state-apply.ts

@@ -20,7 +20,7 @@
 import { execSync, execFileSync } from 'node:child_process';
 import type { ModelDescriptor } from '@everystack/model';
 import { introspectContract, type AuthzContract, type QueryRunner } from './authz-contract';
-import { borrowedSessionRunner, type SessionRunner } from './session';
+import { borrowedSessionRunner, CANONICAL_SEARCH_PATH, type SessionRunner } from './session';
 import { introspectSchema, type SchemaSnapshot } from './schema-introspect';
 import { FUNCTIONS_SQL, contractFunctionRow } from './security-catalog';
 import { generateMigrationSql, HELD_DROP_PREFIX } from './migration-generate';
@@ -572,9 +572,14 @@ export async function applyGeneratedStatements(
   // point; they join the row on the amendment, where their outcome is known.
   const prerequisiteSql = prerequisites
     .flatMap((prerequisite) => [renderStatePrerequisiteGuard(prerequisite), prerequisite.sql]);
+  // The plan is rendered against the canonical path — public bare, non-public qualified — so it
+  // must RUN under it. Under an operator path like `analytics, public`, a bare
+  // `CREATE TYPE "post_status"` would land in analytics. Transaction-local and inside the
+  // batch's own string, so it can neither be skipped nor outlive the batch.
+  const stateBatch = batch.length > 0 ? [renderLocalSearchPath(CANONICAL_SEARCH_PATH), ...batch] : [];
   // A SQL-language prerequisite may read a table this same state edge creates. PostgreSQL
   // validates such bodies at CREATE time unless this transaction-local setting defers it.
-  let batchSql = [...(prerequisites.length > 0 ? ['SET LOCAL check_function_bodies = off'] : []), ...prerequisiteSql, ...batch].join('\n;\n');
+  let batchSql = [...(prerequisites.length > 0 ? ['SET LOCAL check_function_bodies = off'] : []), ...prerequisiteSql, ...stateBatch].join('\n;\n');
   const validationSql = validations.join('\n;\n');
   const started = now();
   try {
@@ -587,13 +592,14 @@ export async function applyGeneratedStatements(
         const originalPath = settings?.search_path;
         if (typeof originalPath !== 'string') throw new Error('could not capture prerequisite search_path; no state was applied.');
         // Defaults and SQL-standard bodies bind names at CREATE time. Use the full declared
-        // path recorded at mint, then restore the exact connection setting before state DDL.
+        // path recorded at mint, then restore the exact connection setting; the state DDL
+        // that follows pins the canonical path itself.
         batchSql = ['SET LOCAL check_function_bodies = off', ...prerequisites.flatMap((prerequisite) => [
           renderStatePrerequisiteGuard(prerequisite),
           ...(prerequisite.searchPath === null ? [] : [renderLocalSearchPath(prerequisite.searchPath)]),
           prerequisite.sql,
           ...(prerequisite.searchPath === null ? [] : [renderLocalSearchPath(originalPath)]),
-        ]), ...batch].join('\n;\n');
+        ]), ...stateBatch].join('\n;\n');
         await transactionRunner(batchSql);
         // `defHash` is PostgreSQL's canonical deparse, so source text cannot predict it. Read it
         // after the CREATE through the OPEN transaction, then write provenance before COMMIT.

package/src/cli/ts-template.ts

@@ -0,0 +1,52 @@
+/**
+ * Escape live text for the body of a template literal in generated source, so the template
+ * evaluates back to EXACTLY that text: backslash first, then backtick, then `${`. Live database
+ * text is data. Unescaped, `${…}` in it ran when the generated file was imported, and a
+ * backslash before a backtick closed the template. Every renderer that puts live text inside
+ * sql`…` uses this one rule.
+ */
+export function templateBody(text: string): string {
+  return text.replace(/\\/g, '\\\\').replace(/`/g, '\\`').replace(/\$\{/g, '\\${');
+}
+
+/**
+ * Live text as a single-quoted string literal in generated source, evaluating back to EXACTLY
+ * that text. Backslash first, then the quote, then every line terminator: a raw newline or
+ * carriage return ends a string literal, so a live name holding one broke the generated file.
+ * U+2028 and U+2029 are legal inside a string since ES2019 but not in every older parser, so
+ * they are escaped too. Ordinary text comes out unchanged.
+ */
+export function tsString(text: string): string {
+  const body = text
+    .replace(/\\/g, '\\\\')
+    .replace(/'/g, "\\'")
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+  return `'${body}'`;
+}
+
+/**
+ * Live text bound for a `//` line comment in generated source. JavaScript ends a line comment
+ * at ANY line terminator (LF, CR, U+2028, U+2029), so a live name holding one ended the comment
+ * and the rest of the name ran as code. Each terminator becomes its visible escape sequence
+ * (`\n`, `\r`, `\u2028`, `\u2029`): the comment stays one line, and a reader still sees that
+ * the live name held a line break. Ordinary text comes out unchanged.
+ */
+export function commentText(text: string): string {
+  return text
+    .replace(/\n/g, '\\n')
+    .replace(/\r/g, '\\r')
+    .replace(/\u2028/g, '\\u2028')
+    .replace(/\u2029/g, '\\u2029');
+}
+
+/**
+ * Live text that is MEANT to span several comment lines (a deparsed predicate in a note): split
+ * on every line terminator, so each piece gets its own `//`. Splitting on `\n` alone left a CR,
+ * U+2028 or U+2029 inside one line, which still ended the comment.
+ */
+export function commentLines(text: string): string[] {
+  return text.split(/\r\n|[\n\r\u2028\u2029]/);
+}