rip-lang 3.14.0 → 3.14.2

package/src/schema.js

@@ -1432,6 +1432,11 @@ function serializeLiteral(v) {
 // its own arg shape — we centralize the parsing here so Layer 2 can rely
 // on normalized structures.
 function compileDirectiveArgsLiteral(name, tokens) {
+  // @idStart requires its arg, so validate before the generic empty-bail.
+  if (name === 'idStart' && !tokens.length) {
+    throw schemaError(null,
+      '@idStart requires an integer literal, e.g. @idStart 10001.');
+  }
   if (!tokens.length) return null;
 
   // Relation directives: `@belongs_to Org`, `@belongs_to Org?`,
@@ -1489,6 +1494,29 @@ function compileDirectiveArgsLiteral(name, tokens) {
     return `[{${parts.join(', ')}}]`;
   }
 
+  // @idStart N sets the seed value for the table's auto-id sequence.
+  // Accepts a single integer literal (optionally negative). Consumed by
+  // .toSQL(); models that never call .toSQL() simply ignore it.
+  if (name === 'idStart') {
+    let tok = tokens[0];
+    let sign = 1;
+    let numTok = tok;
+    if (tok && tok[0] === '-' && tokens[1] && tokens[1][0] === 'NUMBER') {
+      sign = -1;
+      numTok = tokens[1];
+    }
+    if (!numTok || numTok[0] !== 'NUMBER') {
+      throw schemaError(tok || tokens[tokens.length - 1],
+        '@idStart requires an integer literal, e.g. @idStart 10001.');
+    }
+    let n = sign * Number(numTok[1]);
+    if (!Number.isInteger(n)) {
+      throw schemaError(numTok,
+        '@idStart requires an integer literal; got ' + numTok[1] + '.');
+    }
+    return '[{value: ' + n + '}]';
+  }
+
   // Bare flag-like directives (@timestamps, @softDelete) don't take args.
   // Anything else — capture as raw literal tokens conservatively.
   return null;
@@ -1731,6 +1759,14 @@ function schemaError(tok, message) {
 //   :mixin   — non-instantiable; raises `Cannot parse :mixin`
 //   :model   — Phase 4 (the class additionally wires ORM methods)
 
+// Schema runtime ABI version. Bump when the shape of a __schema({...})
+// descriptor or any cross-bundle-visible runtime surface changes
+// incompatibly. Two bundles that disagree on this number can't share
+// one runtime, so a mismatch at load time throws rather than silently
+// fragmenting. Tracks runtime contract — not the rip-lang product
+// semver.
+const SCHEMA_RUNTIME_ABI_VERSION = 1;
+
 const SCHEMA_RUNTIME = `
 // ---- Rip Schema Runtime ----------------------------------------------------
 // Four layers, lazy compilation:
@@ -1740,6 +1776,26 @@ const SCHEMA_RUNTIME = `
 //   3 (validator)    compiled validator plan. Built on first .parse.
 //   4a (ORM plan)    built on first .find/.create/.save.
 //   4b (DDL plan)    built on first .toSQL(). Independent of 4a.
+//
+// Instance-singleton model:
+// The runtime installs itself on globalThis.__ripSchema the first time a
+// compiled bundle executes. Subsequent bundles that inject the same runtime
+// template detect the existing installation and bind to it instead of
+// re-running the body — giving every bundle a single shared registry,
+// adapter, and class identity. The IIFE wrapper below enforces that.
+
+var { __schema, SchemaError, __SchemaRegistry, __schemaSetAdapter } = (function() {
+  if (typeof globalThis !== 'undefined' && globalThis.__ripSchema) {
+    if (globalThis.__ripSchema.__version !== ${SCHEMA_RUNTIME_ABI_VERSION}) {
+      throw new Error(
+        "rip-schema runtime version mismatch: loaded runtime is v" +
+        globalThis.__ripSchema.__version +
+        ", but this bundle expects v" + ${SCHEMA_RUNTIME_ABI_VERSION} +
+        ". Two compiled Rip bundles with incompatible schema runtimes are loaded in the same process."
+      );
+    }
+    return globalThis.__ripSchema;
+  }
 
 class SchemaError extends Error {
   constructor(issues, schemaName, schemaKind) {
@@ -2051,13 +2107,12 @@ class __SchemaDef {
           hooks.set(e.name, e.fn);
           break;
         case 'directive': {
-          if (e.name === 'mixin') {
-            // Deferred to the post-pass so we can dedupe diamond includes
-            // and detect cycles with a full expansion stack.
-            directives.push({ name: e.name, args: e.args || [] });
-            break;
-          }
           directives.push({ name: e.name, args: e.args || [] });
+          // @mixin is recorded but further handling is deferred to the
+          // post-pass so we can dedupe diamond includes and detect
+          // cycles with a full expansion stack. All other directives
+          // get their relation / timestamps / softDelete processing now.
+          if (e.name === 'mixin') break;
           if (e.name === 'timestamps') timestamps = true;
           if (e.name === 'softDelete') softDelete = true;
           const rel = __schemaNormalizeDirectiveRelation(e, this.name);
@@ -2232,11 +2287,20 @@ class __SchemaDef {
         enumerable: false, configurable: true, writable: true,
         value: function() { return def._validateFields(this, true); },
       });
+      // toJSON mirrors the instance's own enumerable properties, which by
+      // construction are: the primary key, declared fields, @timestamps
+      // columns, @softDelete timestamp, @belongs_to FK columns, and any
+      // !> eager-derived fields. Internal state (_dirty, _persisted,
+      // _snapshot) is defined non-enumerable; methods and ~> computed
+      // getters live on the prototype. So iterating own keys picks up
+      // exactly the user-facing wire shape without special-casing each
+      // category — and stays correct when new implicit columns get added
+      // to the runtime.
       Object.defineProperty(klass.prototype, 'toJSON', {
         enumerable: false, configurable: true, writable: true,
         value: function() {
           const out = {};
-          for (const k of norm.fields.keys()) out[k] = this[k];
+          for (const k of Object.keys(this)) out[k] = this[k];
           return out;
         },
       });
@@ -2818,6 +2882,13 @@ async function __schemaSave(def, inst) {
         }
       }
     }
+    // Now that the RETURNING columns (id, @timestamps, FKs) are on the
+    // instance, !> eager-derived fields can see them. Mirrors the hydrate
+    // path, which runs _applyEagerDerived once all declared fields are
+    // populated. Per-docs semantics ("materialize once, not reactive")
+    // still hold — we're firing once, at end of construction, not on
+    // subsequent mutations.
+    def._applyEagerDerived(inst);
     inst._persisted = true;
   } else {
     const sets = [], values = [];
@@ -2874,7 +2945,8 @@ const __SCHEMA_SQL_TYPES = {
 };
 
 function __schemaToSQL(def, options) {
-  const { dropFirst = false, header } = options || {};
+  const opts = options || {};
+  const { dropFirst = false, header } = opts;
   const norm = def._normalize();
   const blocks = [];
   if (header) blocks.push(header);
@@ -2885,6 +2957,23 @@ function __schemaToSQL(def, options) {
     blocks.push('DROP TABLE IF EXISTS ' + table + ' CASCADE;\\nDROP SEQUENCE IF EXISTS ' + seq + ';');
   }
 
+  // Sequence seed: explicit option wins over @idStart directive wins over 1.
+  // DuckDB 1.5.2 does not implement ALTER SEQUENCE ... RESTART WITH N, so the
+  // baseline has to be set at creation — hence the knob lives here, not in a
+  // post-create migration.
+  let idStart = 1;
+  for (const d of norm.directives) {
+    if (d.name === 'idStart' && d.args?.[0] && Number.isInteger(d.args[0].value)) {
+      idStart = d.args[0].value;
+    }
+  }
+  if (opts.idStart !== undefined) {
+    if (!Number.isInteger(opts.idStart)) {
+      throw new Error('schema.toSQL(): idStart must be an integer; got ' + String(opts.idStart));
+    }
+    idStart = opts.idStart;
+  }
+
   const columns = [];
   const indexes = [];
   columns.push('  ' + norm.primaryKey + " INTEGER PRIMARY KEY DEFAULT nextval('" + seq + "')");
@@ -2921,7 +3010,7 @@ function __schemaToSQL(def, options) {
     indexes.push('CREATE ' + u + 'INDEX idx_' + table + '_' + fields.join('_') + ' ON ' + table + ' (' + fields.map(f => '"' + f + '"').join(', ') + ');');
   }
 
-  blocks.push('CREATE SEQUENCE ' + seq + ' START 1;');
+  blocks.push('CREATE SEQUENCE ' + seq + ' START ' + idStart + ';');
   blocks.push('CREATE TABLE ' + table + ' (\\n' + columns.join(',\\n') + '\\n);');
   if (indexes.length) blocks.push(indexes.join('\\n'));
 
@@ -2963,11 +3052,13 @@ function __schema(descriptor) {
   return def;
 }
 
-if (typeof globalThis !== 'undefined') {
-  globalThis.__ripSchema = {
+  const exports = {
     __schema, SchemaError, __SchemaRegistry, __schemaSetAdapter,
+    __version: ${SCHEMA_RUNTIME_ABI_VERSION},
   };
-}
+  if (typeof globalThis !== 'undefined') globalThis.__ripSchema = exports;
+  return exports;
+})();
 
 // === End Schema Runtime ===
 `;
@@ -3042,7 +3133,7 @@ export const SCHEMA_INTRINSIC_DECLS = [
   '  first(): Promise<Instance | null>;',
   '  count(cond?: Record<string, unknown>): Promise<number>;',
   '  create(data: Partial<Data>): Promise<Instance>;',
-  '  toSQL(options?: { dropFirst?: boolean; header?: string }): string;',
+  '  toSQL(options?: { dropFirst?: boolean; header?: string; idStart?: number }): string;',
   '}',
 ];