turbine-orm 0.22.0 → 0.23.1

package/dist/cjs/generate.js

@@ -508,6 +508,10 @@ function serializeColumn(col) {
         `arrayType: '${escSQ(col.arrayType ?? col.pgArrayType)}'`,
         `pgArrayType: '${escSQ(col.pgArrayType)}'`,
     ];
+    // Emit isGenerated only when set (server-generated serial/identity), so the
+    // output stays byte-identical for the common client-default columns.
+    if (col.isGenerated)
+        parts.push(`isGenerated: true`);
     if (col.maxLength !== undefined)
         parts.push(`maxLength: ${col.maxLength}`);
     return `{ ${parts.join(', ')} }`;

package/dist/cjs/introspect.js

@@ -35,6 +35,7 @@ const SQL_COLUMNS = `
     data_type,
     is_nullable,
     column_default,
+    is_identity,
     ordinal_position,
     character_maximum_length
   FROM information_schema.columns
@@ -170,6 +171,11 @@ async function introspectPostgresCatalog(options) {
                     (0, schema_js_1.pgTypeToTs)(isArray ? dialectType : baseType, isNullable),
                 nullable: isNullable,
                 hasDefault: row.column_default !== null,
+                // Server-generated = a sequence default (serial/BIGSERIAL → nextval(…))
+                // or an IDENTITY column. Distinct from a client-side default expression
+                // (gen_random_uuid(), now()), which Turbine must still synthesize.
+                isGenerated: (typeof row.column_default === 'string' && row.column_default.includes('nextval(')) ||
+                    row.is_identity === 'YES',
                 isArray,
                 arrayType,
                 pgArrayType: arrayType,

package/dist/cjs/powdb.js

@@ -248,18 +248,32 @@ function isDateColumn(col) {
  * Generate PowQL DDL (`type T { … }`) for every table in a schema. Used to
  * provision a PowDB database from a code-first `defineSchema`/`SchemaMetadata`
  * (PowDB has no migration runner yet). The primary key column is declared
- * `required unique`; non-nullable columns are `required`.
+ * `required unique`; non-nullable columns are `required`. A server-generated
+ * column ({@link ColumnMetadata.isGenerated}) that maps to PowQL `int` gets the
+ * `auto` modifier, so PowDB assigns a monotonic id on insert and Turbine stops
+ * synthesizing a client-side value for it.
  */
 function powqlSchemaDDL(schema) {
     const stmts = [];
     for (const meta of Object.values(schema.tables)) {
         const pkSet = new Set(meta.primaryKey);
+        // PowDB's `unique` is single-column only — there is no composite-unique
+        // constraint (`add unique` takes one `.column`). So the per-field `unique`
+        // modifier is emitted only for a single-column PK; a composite PK (e.g. a
+        // m2m junction's `(source_id, target_id)`) marks its columns `required` but
+        // cannot enforce the tuple's uniqueness at the engine level.
+        const pkIsSingle = meta.primaryKey.length === 1;
         const fields = meta.columns.map((col) => {
             const mods = [];
             if (!col.nullable || pkSet.has(col.name))
                 mods.push('required');
-            if (pkSet.has(col.name))
+            if (pkSet.has(col.name) && pkIsSingle)
                 mods.push('unique');
+            // `auto` = server-generated monotonic int. PowDB requires it be `int` and
+            // rejects it alongside a `default`; non-int generated columns fall back to
+            // a plain typed column (Turbine assigns the value client-side instead).
+            if (col.isGenerated && powqlColumnType(col) === 'int')
+                mods.push('auto');
             return `  ${mods.join(' ')}${mods.length ? ' ' : ''}${col.name}: ${powqlColumnType(col)}`;
         });
         stmts.push(`type ${meta.name} {\n${fields.join(',\n')}\n}`);