rip-lang 3.14.1 → 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;
@@ -2259,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;
         },
       });
@@ -2845,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 = [];
@@ -2901,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);
@@ -2912,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 + "')");
@@ -2948,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'));
 
@@ -3071,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;',
   '}',
 ];