turbine-orm 0.23.1 → 0.24.0

package/dist/schema-builder.d.ts

@@ -24,7 +24,7 @@
  */
 import type { SchemaMetadata } from './schema.js';
 /** Shorthand type names that map to Postgres column types */
-export type ColumnTypeName = 'serial' | 'bigint' | 'integer' | 'smallint' | 'text' | 'varchar' | 'boolean' | 'timestamp' | 'date' | 'json' | 'uuid' | 'real' | 'double' | 'numeric' | 'bytea';
+export type ColumnTypeName = 'serial' | 'bigserial' | 'bigint' | 'integer' | 'smallint' | 'text' | 'varchar' | 'boolean' | 'timestamp' | 'timestamptz' | 'date' | 'json' | 'jsonb' | 'uuid' | 'real' | 'double' | 'numeric' | 'bytea';
 /** Column definition as a plain object. This is what users write. */
 export interface ColumnDef {
     /** Column type (required) */
@@ -45,7 +45,7 @@ export interface ColumnDef {
     maxLength?: number;
 }
 /** Postgres-level column type (uppercase, as used in DDL) */
-export type ColumnType = 'BIGSERIAL' | 'BIGINT' | 'INTEGER' | 'SMALLINT' | 'TEXT' | 'BOOLEAN' | 'TIMESTAMPTZ' | 'JSONB' | 'UUID' | 'REAL' | 'DOUBLE PRECISION' | 'NUMERIC' | 'BYTEA' | 'DATE' | 'VARCHAR';
+export type ColumnType = 'SERIAL' | 'BIGSERIAL' | 'BIGINT' | 'INTEGER' | 'SMALLINT' | 'TEXT' | 'BOOLEAN' | 'TIMESTAMPTZ' | 'JSONB' | 'UUID' | 'REAL' | 'DOUBLE PRECISION' | 'NUMERIC' | 'BYTEA' | 'DATE' | 'VARCHAR';
 export interface ColumnConfig {
     type: ColumnType;
     isPrimaryKey: boolean;
@@ -164,6 +164,7 @@ export declare class ColumnBuilder {
     private _config;
     constructor();
     serial(): this;
+    bigserial(): this;
     bigint(): this;
     integer(): this;
     smallint(): this;
@@ -171,8 +172,10 @@ export declare class ColumnBuilder {
     varchar(length: number): this;
     boolean(): this;
     timestamp(): this;
+    timestamptz(): this;
     date(): this;
     json(): this;
+    jsonb(): this;
     uuid(): this;
     real(): this;
     doublePrecision(): this;
@@ -188,7 +191,7 @@ export declare class ColumnBuilder {
 }
 /** @deprecated Use defineSchema() with plain objects instead */
 type ColumnProxy = {
-    [K in 'serial' | 'bigint' | 'integer' | 'smallint' | 'text' | 'boolean' | 'timestamp' | 'date' | 'json' | 'uuid' | 'real' | 'doublePrecision' | 'numeric' | 'bytea']: () => ColumnBuilder;
+    [K in 'serial' | 'bigserial' | 'bigint' | 'integer' | 'smallint' | 'text' | 'boolean' | 'timestamp' | 'timestamptz' | 'date' | 'json' | 'jsonb' | 'uuid' | 'real' | 'doublePrecision' | 'numeric' | 'bytea']: () => ColumnBuilder;
 } & {
     varchar: (length: number) => ColumnBuilder;
 };
@@ -224,4 +227,3 @@ export declare function table(columns: Record<string, ColumnBuilder>): TableDef;
  */
 export declare function applyManyToManyRelations(meta: SchemaMetadata, def: SchemaDef): SchemaMetadata;
 export { camelToSnake } from './schema.js';
-//# sourceMappingURL=schema-builder.d.ts.map

package/dist/schema-builder.js

@@ -24,16 +24,28 @@
  */
 /** Maps shorthand names to actual Postgres type strings */
 const TYPE_MAP = {
-    serial: 'BIGSERIAL',
+    // `serial` maps to SERIAL (int4). Its values fit in a JS `number` and pg
+    // returns them as numbers — so the generated `number` type is accurate.
+    // For 64-bit auto-increment keys use `bigserial` (int8), noting that values
+    // above Number.MAX_SAFE_INTEGER read back as string. (Changed in 0.24.0;
+    // `serial` previously emitted BIGSERIAL.)
+    serial: 'SERIAL',
+    bigserial: 'BIGSERIAL',
     bigint: 'BIGINT',
     integer: 'INTEGER',
     smallint: 'SMALLINT',
     text: 'TEXT',
     varchar: 'VARCHAR',
     boolean: 'BOOLEAN',
+    // `timestamp` is an honest alias for TIMESTAMPTZ (timezone-aware) — Turbine
+    // has always emitted TIMESTAMPTZ for it. `timestamptz` is the explicit spelling.
     timestamp: 'TIMESTAMPTZ',
+    timestamptz: 'TIMESTAMPTZ',
     date: 'DATE',
+    // `json` is an alias for JSONB (Turbine has always emitted JSONB). `jsonb`
+    // is the explicit spelling.
     json: 'JSONB',
+    jsonb: 'JSONB',
     uuid: 'UUID',
     real: 'REAL',
     double: 'DOUBLE PRECISION',
@@ -178,6 +190,11 @@ export class ColumnBuilder {
         };
     }
     serial() {
+        // See TYPE_MAP: `serial` is SERIAL (int4) as of 0.24.0. Use bigserial() for 64-bit.
+        this._config.type = 'SERIAL';
+        return this;
+    }
+    bigserial() {
         this._config.type = 'BIGSERIAL';
         return this;
     }
@@ -210,6 +227,10 @@ export class ColumnBuilder {
         this._config.type = 'TIMESTAMPTZ';
         return this;
     }
+    timestamptz() {
+        this._config.type = 'TIMESTAMPTZ';
+        return this;
+    }
     date() {
         this._config.type = 'DATE';
         return this;
@@ -218,6 +239,10 @@ export class ColumnBuilder {
         this._config.type = 'JSONB';
         return this;
     }
+    jsonb() {
+        this._config.type = 'JSONB';
+        return this;
+    }
     uuid() {
         this._config.type = 'UUID';
         return this;
@@ -269,14 +294,17 @@ export class ColumnBuilder {
 /** Type guard: is `prop` a known nullary ColumnBuilder type method? */
 function isNullaryColumnType(prop) {
     return (prop === 'serial' ||
+        prop === 'bigserial' ||
         prop === 'bigint' ||
         prop === 'integer' ||
         prop === 'smallint' ||
         prop === 'text' ||
         prop === 'boolean' ||
         prop === 'timestamp' ||
+        prop === 'timestamptz' ||
         prop === 'date' ||
         prop === 'json' ||
+        prop === 'jsonb' ||
         prop === 'uuid' ||
         prop === 'real' ||
         prop === 'doublePrecision' ||
@@ -385,4 +413,3 @@ export function applyManyToManyRelations(meta, def) {
 // Helpers
 // ---------------------------------------------------------------------------
 export { camelToSnake } from './schema.js';
-//# sourceMappingURL=schema-builder.js.map

package/dist/schema-sql.d.ts

@@ -77,4 +77,3 @@ export declare function schemaPush(schema: SchemaDef, connectionString: string,
  * Useful for printing or saving to a .sql file.
  */
 export declare function schemaToSQLString(schema: SchemaDef, options?: SchemaSqlOptions): string;
-//# sourceMappingURL=schema-sql.d.ts.map

package/dist/schema-sql.js

@@ -7,6 +7,15 @@
 import pg from 'pg';
 import { postgresDialect } from './dialect.js';
 import { camelToSnake } from './schema.js';
+/**
+ * Whether a resolved column type is an auto-increment pseudo-type (SERIAL /
+ * BIGSERIAL). These carry an implicit sequence default and NOT NULL, and their
+ * underlying integer width (int4 vs int8) is never auto-migrated by diff — a
+ * width change on a live PK is destructive and must be done by hand.
+ */
+function isSerialType(type) {
+    return type === 'SERIAL' || type === 'BIGSERIAL';
+}
 // ---------------------------------------------------------------------------
 // SQL Generation — SchemaDef → CREATE TABLE statements
 // ---------------------------------------------------------------------------
@@ -154,7 +163,7 @@ function generateColumnDef(fieldName, config, resolveRef, dialect = postgresDial
     //   2. Is a serial (BIGSERIAL implies NOT NULL), OR
     //   3. Has a primary key (PKs are NOT NULL)
     // A column is left nullable if .nullable() was called.
-    const isSerial = config.type === 'BIGSERIAL';
+    const isSerial = isSerialType(config.type);
     const implicitNotNull = isSerial || config.isPrimaryKey;
     const notNull = config.isNotNull && !implicitNotNull;
     // DEFAULT
@@ -343,9 +352,13 @@ export async function schemaDiff(schema, connectionString) {
                     result.reverseStatements.unshift(reverseSql);
                     continue;
                 }
-                // Check type mismatch
+                // Check type mismatch. Serial/bigserial columns are exempt: their
+                // underlying int4/int8 width must never be auto-altered on a live table
+                // (a downcast on a PK loses data / breaks the sequence). This also
+                // preserves back-compat for DBs whose `serial` columns were created as
+                // BIGSERIAL (int8) before 0.24.0 — `push` won't try to shrink them.
                 const expectedUdt = schemaTypeToUdt(config);
-                if (expectedUdt && dbCol.udtName !== expectedUdt) {
+                if (expectedUdt && !isSerialType(config.type) && dbCol.udtName !== expectedUdt) {
                     const sqlType = config.type === 'VARCHAR' && config.maxLength ? `VARCHAR(${config.maxLength})` : config.type;
                     const oldSqlType = udtToSqlType(dbCol.udtName, dbCol.maxLength);
                     const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} TYPE ${sqlType} USING ${dialect.quoteIdentifier(snakeName)}::${sqlType};`;
@@ -355,7 +368,7 @@ export async function schemaDiff(schema, connectionString) {
                     result.reverseStatements.unshift(reverseSql);
                 }
                 // Check NOT NULL mismatch
-                const shouldBeNotNull = config.isNotNull || config.isPrimaryKey || config.type === 'BIGSERIAL';
+                const shouldBeNotNull = config.isNotNull || config.isPrimaryKey || isSerialType(config.type);
                 const isCurrentlyNullable = dbCol.isNullable;
                 if (shouldBeNotNull && isCurrentlyNullable && !config.isNullable) {
                     const sql = `ALTER TABLE ${dialect.quoteIdentifier(tableName)} ALTER COLUMN ${dialect.quoteIdentifier(snakeName)} SET NOT NULL;`;
@@ -372,7 +385,7 @@ export async function schemaDiff(schema, connectionString) {
                     result.reverseStatements.unshift(reverseSql);
                 }
                 // Check DEFAULT value mismatch
-                const isSerial = config.type === 'BIGSERIAL';
+                const isSerial = isSerialType(config.type);
                 if (!isSerial) {
                     const schemaDefault = config.defaultValue ? normalizeDefault(config.defaultValue) : null;
                     const dbDefault = dbCol.columnDefault;
@@ -451,6 +464,7 @@ export async function schemaDiff(schema, connectionString) {
  */
 function schemaTypeToUdt(config) {
     const map = {
+        SERIAL: 'int4',
         BIGSERIAL: 'int8',
         BIGINT: 'int8',
         INTEGER: 'int4',
@@ -567,4 +581,3 @@ export function schemaToSQLString(schema, options) {
     const statements = schemaToSQL(schema, options);
     return `${statements.join('\n\n')}\n`;
 }
-//# sourceMappingURL=schema-sql.js.map

package/dist/schema.d.ts

@@ -122,4 +122,3 @@ export declare function camelToSnake(s: string): string;
 export declare function snakeToPascal(s: string): string;
 /** Naive singularize: "posts" → "post", "categories" → "category" */
 export declare function singularize(s: string): string;
-//# sourceMappingURL=schema.d.ts.map

package/dist/schema.js

@@ -146,4 +146,3 @@ export function singularize(s) {
         return s.slice(0, -1);
     return s;
 }
-//# sourceMappingURL=schema.js.map

package/dist/serverless.d.ts

@@ -112,4 +112,3 @@ export interface TurbineHttpOptions extends Pick<TurbineConfig, 'logging' | 'def
  * ```
  */
 export declare function turbineHttp(pool: PgCompatPool, schema: SchemaMetadata, options?: TurbineHttpOptions): TurbineClient;
-//# sourceMappingURL=serverless.d.ts.map

package/dist/serverless.js

@@ -106,4 +106,3 @@ import { TurbineClient } from './client.js';
 export function turbineHttp(pool, schema, options = {}) {
     return new TurbineClient({ pool, ...options }, schema);
 }
-//# sourceMappingURL=serverless.js.map

package/dist/sqlite.d.ts

@@ -141,4 +141,3 @@ export interface TurbineSqliteOptions extends Pick<TurbineConfig, 'logging' | 'd
  */
 export declare function turbineSqlite(target: string | DatabaseSync, schema: SchemaMetadata, options?: TurbineSqliteOptions): TurbineClient;
 export {};
-//# sourceMappingURL=sqlite.d.ts.map

package/dist/sqlite.js

@@ -839,4 +839,3 @@ export function turbineSqlite(target, schema, options = {}) {
         warnOnUnlimited: options.warnOnUnlimited,
     }, schema);
 }
-//# sourceMappingURL=sqlite.js.map

package/dist/typed-sql.d.ts

@@ -100,4 +100,3 @@ export declare class TypedSqlQuery<T extends Record<string, unknown>> implements
      */
     scalar<V = T[keyof T]>(): Promise<V | null>;
 }
-//# sourceMappingURL=typed-sql.d.ts.map

package/dist/typed-sql.js

@@ -144,4 +144,3 @@ export class TypedSqlQuery {
         return first[keys[0]];
     }
 }
-//# sourceMappingURL=typed-sql.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "turbine-orm",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "Postgres-native TypeScript ORM — runs on Neon, Vercel Postgres, Cloudflare, Supabase. Streaming cursors, typed errors, single-query nested relations. One dependency, no WASM engine",
   "type": "module",
   "exports": {
@@ -102,13 +102,13 @@
     "@biomejs/biome": "^2.4.10",
     "@size-limit/esbuild": "^12.1.0",
     "@size-limit/file": "^12.1.0",
-    "@types/node": "^22.10.0",
+    "@types/node": "^26.1.0",
     "c8": "^11.0.0",
     "husky": "^9.1.7",
-    "lint-staged": "^16.4.0",
+    "lint-staged": "^17.0.8",
     "@zvndev/powdb-client": "^0.8.0",
     "@zvndev/powdb-embedded": "^0.8.0",
-    "mssql": "^11.0.1",
+    "mssql": "^12.7.0",
     "mysql2": "^3.22.5",
     "size-limit": "^12.1.0",
     "tsx": "^4.19.0",