@everystack/model 0.4.0 → 0.4.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@everystack/model",
-  "version": "0.4.0",
+  "version": "0.4.2",
   "description": "Declare a table's schema, validation, and authorization once — compiled to migrations, RLS, and handler config",
   "license": "AGPL-3.0-only",
   "publishConfig": {

package/src/derived.ts

@@ -27,6 +27,21 @@ import type { FieldBuilder } from './field';
 /** Anything a derived object can declare a dependency on — order derives from these refs. */
 export type DependsOnRef = ModelDescriptor | DerivedDescriptor;
 
+/**
+ * The loud undefined gate. A missing named import under CJS interop evaluates to
+ * `undefined` and, unchecked, dies layers later as `'table' in undefined` with no
+ * context. Every ref list rejects the hole HERE, naming the owner, the list, the
+ * index, and the likely cause.
+ */
+export function rejectHoles(context: string, listName: string, list: readonly unknown[] | undefined): void {
+  if (!list) return;
+  list.forEach((entry, i) => {
+    if (entry == null) {
+      throw new Error(`${context}: ${listName}[${i}] is ${entry === undefined ? 'undefined' : 'null'} — renamed or missing import?`);
+    }
+  });
+}
+
 /**
  * Relations (views/matviews) carry read-only authz in v1; functions carry execute.
  * The row-scoped condition keys (`owner`, `via`, `where`, `sql`) are meaningless on
@@ -121,6 +136,9 @@ export interface TriggerSpec {
  * the trigger attaches — defineModel / defineView.
  */
 export function trigger(name: string, def: TriggerDefinition): TriggerSpec {
+  if (def.execute == null) {
+    throw new Error(`trigger '${name}': execute is ${def.execute === undefined ? 'undefined' : 'null'} — renamed or missing import?`);
+  }
   const events = EVENT_ORDER.filter((e) => def.events.includes(e));
   if (events.length === 0) throw new Error(`trigger '${name}': declare at least one event.`);
   if (def.of && !events.includes('update')) {
@@ -151,6 +169,7 @@ export function trigger(name: string, def: TriggerDefinition): TriggerSpec {
 
 /** The legality rules that depend on the trigger's TARGET (table vs view). */
 export function validateTriggersFor(target: 'table' | 'view', owner: string, triggers: TriggerSpec[]): void {
+  rejectHoles(`${target} '${owner}'`, 'triggers', triggers);
   for (const t of triggers) {
     if (target === 'table' && t.timing === 'insteadOf') {
       throw new Error(`table '${owner}', trigger '${t.name}': INSTEAD OF is a view trigger — attach it to the defineView it rewrites.`);
@@ -183,6 +202,9 @@ export interface SetofReturn {
 }
 
 export function setof(ref: SetofReturn['setof']): SetofReturn {
+  if (ref == null) {
+    throw new Error(`setof(): ref is ${ref === undefined ? 'undefined' : 'null'} — renamed or missing import?`);
+  }
   return { setof: ref };
 }
 
@@ -219,6 +241,7 @@ export interface FunctionDescriptor {
 }
 
 export function defineFunction(name: string, def: FunctionDefinition): FunctionDescriptor {
+  rejectHoles(`function '${name}'`, 'dependsOn', def.dependsOn);
   const security = def.security ?? 'invoker';
   if (security === 'definer' && (!def.searchPath || def.searchPath.length === 0)) {
     throw new Error(
@@ -306,6 +329,7 @@ export interface ViewDescriptor {
 }
 
 export function defineView(name: string, def: ViewDefinition): ViewDescriptor {
+  rejectHoles(`view '${name}'`, 'dependsOn', def.dependsOn);
   if (typeof def.securityInvoker !== 'boolean') {
     throw new Error(
       `view '${name}': securityInvoker is a required decision — true (readers' own RLS applies through the view) or false (definer semantics: the sealed-slice pattern; the body must not leak).`,
@@ -363,6 +387,7 @@ export interface MaterializedViewDescriptor {
 }
 
 export function defineMaterializedView(name: string, def: MaterializedViewDefinition): MaterializedViewDescriptor {
+  rejectHoles(`materialized view '${name}'`, 'dependsOn', def.dependsOn);
   validateRelationAbilities('materialized view', name, def.abilities ?? []);
   validatePrivateContradiction('materialized view', name, def.private, def.abilities);
   validateRelationFields('materialized view', name, def.fields, def.private);
@@ -460,6 +485,7 @@ export interface SqlDescriptor {
  * gates skip 'sql'-kind objects: what this hatch declares is on its author.
  */
 export function defineSql(name: string, def: SqlDefinition): SqlDescriptor {
+  rejectHoles(`sql '${name}'`, 'dependsOn', def.dependsOn);
   if (!def.kind || !def.kind.trim()) {
     throw new Error(`defineSql '${name}': kind is required — the reconciler drops and joins objects by kind.`);
   }

package/src/model.ts

@@ -124,6 +124,22 @@ export function defineModel(table: string, def: ModelDefinition): ModelDescripto
       throw new Error(`model '${table}': can('execute') is a function ability — declare it on the defineFunction it gates.`);
     }
   }
+
+  // An array field's value default must be a JS array — `.default([])`, not the
+  // Postgres array literal `.default("{}")`. The literal is an implementation
+  // detail that leaks past the generator into drizzle's typed array `.default()`
+  // (which wants `string[] | SQL`) and fails tsc. Reject it at authoring time.
+  for (const [name, f] of Object.entries(def.fields)) {
+    const spec = f.spec;
+    if (spec.isArray && spec.defaultKind === 'value' && spec.default != null && !Array.isArray(spec.default)) {
+      throw new Error(
+        `model '${table}': field '${name}' is an array — its .default() takes a JS array, ` +
+          `e.g. .default([]), not ${JSON.stringify(spec.default)}. ` +
+          `For a SQL expression default use sql\`\` via .defaultSql().`,
+      );
+    }
+  }
+
   validateTriggersFor('table', table, def.triggers ?? []);
 
   return {

package/src/module.ts

@@ -21,6 +21,7 @@
 
 import type { ModelDescriptor } from './model';
 import type { DerivedDescriptor, SequenceDescriptor } from './derived';
+import { rejectHoles } from './derived';
 
 export interface ModuleDefinition {
   /** The package's Models (schema + authz). */
@@ -65,6 +66,11 @@ export interface Module {
 
 /** Declare a package's database slice. Empty fields default to nothing — a models-only module is fine. */
 export function defineModule(def: ModuleDefinition): Module {
+  // The loud undefined gate — a missing import composes as a hole; name it here,
+  // at the module boundary, before any list is flattened or iterated.
+  rejectHoles('defineModule', 'models', def.models);
+  rejectHoles('defineModule', 'derived', def.derived);
+  rejectHoles('defineModule', 'sequences', def.sequences);
   // Derived identity is one name per kind: `DROP FUNCTION` renders no argument list, so
   // v1 rejects function overloads outright, and same-name relations collide in the
   // catalog anyway — caught here, at composition, before any SQL exists.