turbine-orm 0.5.0 → 0.7.0

package/dist/errors.d.ts

@@ -0,0 +1,138 @@
+/**
+ * turbine-orm — Error types
+ *
+ * Typed errors with error codes for programmatic handling.
+ * All Turbine errors extend TurbineError which includes a `code` property.
+ */
+/** Error codes for all Turbine errors */
+export declare const TurbineErrorCode: {
+    readonly NOT_FOUND: "TURBINE_E001";
+    readonly TIMEOUT: "TURBINE_E002";
+    readonly VALIDATION: "TURBINE_E003";
+    readonly CONNECTION: "TURBINE_E004";
+    readonly RELATION: "TURBINE_E005";
+    readonly MIGRATION: "TURBINE_E006";
+    readonly CIRCULAR_RELATION: "TURBINE_E007";
+    readonly UNIQUE_VIOLATION: "TURBINE_E008";
+    readonly FOREIGN_KEY_VIOLATION: "TURBINE_E009";
+    readonly NOT_NULL_VIOLATION: "TURBINE_E010";
+    readonly CHECK_VIOLATION: "TURBINE_E011";
+};
+export type TurbineErrorCode = (typeof TurbineErrorCode)[keyof typeof TurbineErrorCode];
+/** Base error class for all Turbine errors */
+export declare class TurbineError extends Error {
+    readonly code: TurbineErrorCode;
+    constructor(code: TurbineErrorCode, message: string, options?: {
+        cause?: unknown;
+    });
+}
+/**
+ * Thrown when a record is not found (findUniqueOrThrow, findFirstOrThrow,
+ * update/delete against a non-matching row, etc.)
+ *
+ * Supports two call styles for back-compat:
+ *   - `new NotFoundError()` / `new NotFoundError('custom message')`
+ *   - `new NotFoundError({ table, where, operation, cause, message })`
+ *
+ * When called with an options object and no explicit `message`, a Prisma-style
+ * message is built automatically, e.g.:
+ *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ */
+export declare class NotFoundError extends TurbineError {
+    readonly table?: string;
+    readonly where?: unknown;
+    readonly operation?: string;
+    constructor(input?: string | {
+        table?: string;
+        where?: unknown;
+        operation?: string;
+        cause?: unknown;
+        message?: string;
+    });
+}
+/** Thrown when a query or transaction exceeds the configured timeout */
+export declare class TimeoutError extends TurbineError {
+    readonly timeoutMs: number;
+    constructor(timeoutMs: number, context?: string);
+}
+/** Thrown when query arguments fail validation (unknown column, invalid operator, etc.) */
+export declare class ValidationError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when a database connection fails */
+export declare class ConnectionError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when a relation reference is invalid */
+export declare class RelationError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when a migration operation fails */
+export declare class MigrationError extends TurbineError {
+    constructor(message: string);
+}
+/** Thrown when circular relation nesting is detected */
+export declare class CircularRelationError extends TurbineError {
+    readonly path: string[];
+    constructor(path: string[]);
+}
+/** Thrown when a UNIQUE constraint is violated (pg code 23505) */
+export declare class UniqueConstraintError extends TurbineError {
+    readonly constraint?: string;
+    readonly columns?: string[];
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        columns?: string[];
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a FOREIGN KEY constraint is violated (pg code 23503) */
+export declare class ForeignKeyError extends TurbineError {
+    readonly constraint?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a NOT NULL constraint is violated (pg code 23502) */
+export declare class NotNullViolationError extends TurbineError {
+    readonly column?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        column?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/** Thrown when a CHECK constraint is violated (pg code 23514) */
+export declare class CheckConstraintError extends TurbineError {
+    readonly constraint?: string;
+    readonly table?: string;
+    constructor(opts?: {
+        constraint?: string;
+        table?: string;
+        message?: string;
+        cause?: unknown;
+    });
+}
+/**
+ * Translate a pg driver error into a typed Turbine error.
+ * If the error doesn't match a known constraint code, returns it unchanged.
+ *
+ * Maps:
+ *   23505 (unique_violation)      -> UniqueConstraintError
+ *   23503 (foreign_key_violation) -> ForeignKeyError
+ *   23502 (not_null_violation)    -> NotNullViolationError
+ *   23514 (check_violation)       -> CheckConstraintError
+ *
+ * The original pg error is preserved as `.cause` on the wrapped error.
+ */
+export declare function wrapPgError(err: unknown): unknown;
+//# sourceMappingURL=errors.d.ts.map

package/dist/errors.js

@@ -0,0 +1,278 @@
+/**
+ * turbine-orm — Error types
+ *
+ * Typed errors with error codes for programmatic handling.
+ * All Turbine errors extend TurbineError which includes a `code` property.
+ */
+/** Error codes for all Turbine errors */
+export const TurbineErrorCode = {
+    NOT_FOUND: 'TURBINE_E001',
+    TIMEOUT: 'TURBINE_E002',
+    VALIDATION: 'TURBINE_E003',
+    CONNECTION: 'TURBINE_E004',
+    RELATION: 'TURBINE_E005',
+    MIGRATION: 'TURBINE_E006',
+    CIRCULAR_RELATION: 'TURBINE_E007',
+    UNIQUE_VIOLATION: 'TURBINE_E008',
+    FOREIGN_KEY_VIOLATION: 'TURBINE_E009',
+    NOT_NULL_VIOLATION: 'TURBINE_E010',
+    CHECK_VIOLATION: 'TURBINE_E011',
+};
+/** Base error class for all Turbine errors */
+export class TurbineError extends Error {
+    code;
+    constructor(code, message, options) {
+        super(message, options);
+        this.name = 'TurbineError';
+        this.code = code;
+    }
+}
+/**
+ * Thrown when a record is not found (findUniqueOrThrow, findFirstOrThrow,
+ * update/delete against a non-matching row, etc.)
+ *
+ * Supports two call styles for back-compat:
+ *   - `new NotFoundError()` / `new NotFoundError('custom message')`
+ *   - `new NotFoundError({ table, where, operation, cause, message })`
+ *
+ * When called with an options object and no explicit `message`, a Prisma-style
+ * message is built automatically, e.g.:
+ *   `[turbine] findUniqueOrThrow on "users" found no record matching where: {"id":1}`
+ */
+export class NotFoundError extends TurbineError {
+    table;
+    where;
+    operation;
+    constructor(input) {
+        // Back-compat: string argument (or undefined) — replicate legacy behavior.
+        if (typeof input === 'string' || input === undefined) {
+            super(TurbineErrorCode.NOT_FOUND, input ?? 'Record not found');
+            this.name = 'NotFoundError';
+            return;
+        }
+        const { table, where, operation, cause } = input;
+        let message = input.message;
+        if (!message) {
+            if (operation && table) {
+                const wherePart = where !== undefined ? ` matching where: ${JSON.stringify(where)}` : '';
+                message = `[turbine] ${operation} on "${table}" found no record${wherePart}`;
+            }
+            else if (table) {
+                const wherePart = where !== undefined ? ` matching where ${JSON.stringify(where)}` : '';
+                message = `[turbine] No record found in "${table}"${wherePart}`;
+            }
+            else {
+                message = '[turbine] Record not found';
+            }
+        }
+        super(TurbineErrorCode.NOT_FOUND, message, { cause });
+        this.name = 'NotFoundError';
+        this.table = table;
+        this.where = where;
+        this.operation = operation;
+    }
+}
+/** Thrown when a query or transaction exceeds the configured timeout */
+export class TimeoutError extends TurbineError {
+    timeoutMs;
+    constructor(timeoutMs, context = 'Query') {
+        super(TurbineErrorCode.TIMEOUT, `[turbine] ${context} timed out after ${timeoutMs}ms`);
+        this.name = 'TimeoutError';
+        this.timeoutMs = timeoutMs;
+    }
+}
+/** Thrown when query arguments fail validation (unknown column, invalid operator, etc.) */
+export class ValidationError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.VALIDATION, message);
+        this.name = 'ValidationError';
+    }
+}
+/** Thrown when a database connection fails */
+export class ConnectionError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.CONNECTION, message);
+        this.name = 'ConnectionError';
+    }
+}
+/** Thrown when a relation reference is invalid */
+export class RelationError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.RELATION, message);
+        this.name = 'RelationError';
+    }
+}
+/** Thrown when a migration operation fails */
+export class MigrationError extends TurbineError {
+    constructor(message) {
+        super(TurbineErrorCode.MIGRATION, message);
+        this.name = 'MigrationError';
+    }
+}
+/** Thrown when circular relation nesting is detected */
+export class CircularRelationError extends TurbineError {
+    path;
+    constructor(path) {
+        super(TurbineErrorCode.CIRCULAR_RELATION, `[turbine] Circular or too-deep relation nesting detected: ${path.join(' → ')}. Maximum nesting depth is 10.`);
+        this.name = 'CircularRelationError';
+        this.path = path;
+    }
+}
+// ---------------------------------------------------------------------------
+// Database constraint violation errors
+// ---------------------------------------------------------------------------
+/**
+ * Extract the `detail` string from a pg-style error stored as `cause`.
+ * Returns undefined if the cause is not an object or has no detail.
+ */
+function detailFromCause(cause) {
+    if (!cause || typeof cause !== 'object')
+        return undefined;
+    const d = cause.detail;
+    return typeof d === 'string' && d.length > 0 ? d : undefined;
+}
+/** Thrown when a UNIQUE constraint is violated (pg code 23505) */
+export class UniqueConstraintError extends TurbineError {
+    constraint;
+    columns;
+    table;
+    constructor(opts = {}) {
+        const { constraint, columns, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            const columnsPart = columns && columns.length > 0 ? ` (${columns.join(', ')})` : '';
+            message = `[turbine] Unique constraint violation${constraintPart}${columnsPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.UNIQUE_VIOLATION, message, { cause });
+        this.name = 'UniqueConstraintError';
+        this.constraint = constraint;
+        this.columns = columns;
+        this.table = table;
+    }
+}
+/** Thrown when a FOREIGN KEY constraint is violated (pg code 23503) */
+export class ForeignKeyError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Foreign key constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.FOREIGN_KEY_VIOLATION, message, { cause });
+        this.name = 'ForeignKeyError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+/** Thrown when a NOT NULL constraint is violated (pg code 23502) */
+export class NotNullViolationError extends TurbineError {
+    column;
+    table;
+    constructor(opts = {}) {
+        const { column, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const columnPart = column ? ` on column "${column}"` : '';
+            message = `[turbine] NOT NULL constraint violation${columnPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.NOT_NULL_VIOLATION, message, { cause });
+        this.name = 'NotNullViolationError';
+        this.column = column;
+        this.table = table;
+    }
+}
+/** Thrown when a CHECK constraint is violated (pg code 23514) */
+export class CheckConstraintError extends TurbineError {
+    constraint;
+    table;
+    constructor(opts = {}) {
+        const { constraint, table, cause } = opts;
+        let message = opts.message;
+        if (!message) {
+            const constraintPart = constraint ? ` on ${constraint}` : '';
+            message = `[turbine] Check constraint violation${constraintPart}`;
+            const detail = detailFromCause(cause);
+            if (detail)
+                message += `: ${detail}`;
+        }
+        super(TurbineErrorCode.CHECK_VIOLATION, message, { cause });
+        this.name = 'CheckConstraintError';
+        this.constraint = constraint;
+        this.table = table;
+    }
+}
+/**
+ * Parse column names out of a pg `detail` string like:
+ *   "Key (email)=(foo@bar) already exists."
+ *   "Key (col1, col2)=(v1, v2) already exists."
+ */
+function parseColumnsFromDetail(detail) {
+    const m = detail.match(/^Key \(([^)]+)\)/);
+    if (!m)
+        return undefined;
+    return m[1].split(',').map((s) => s.trim());
+}
+/**
+ * Translate a pg driver error into a typed Turbine error.
+ * If the error doesn't match a known constraint code, returns it unchanged.
+ *
+ * Maps:
+ *   23505 (unique_violation)      -> UniqueConstraintError
+ *   23503 (foreign_key_violation) -> ForeignKeyError
+ *   23502 (not_null_violation)    -> NotNullViolationError
+ *   23514 (check_violation)       -> CheckConstraintError
+ *
+ * The original pg error is preserved as `.cause` on the wrapped error.
+ */
+export function wrapPgError(err) {
+    if (!err || typeof err !== 'object')
+        return err;
+    const e = err;
+    if (!e.code)
+        return err;
+    switch (e.code) {
+        case '23505': {
+            const cols = e.detail ? parseColumnsFromDetail(e.detail) : undefined;
+            return new UniqueConstraintError({
+                constraint: e.constraint,
+                columns: cols,
+                table: e.table,
+                cause: err,
+            });
+        }
+        case '23503':
+            return new ForeignKeyError({
+                constraint: e.constraint,
+                table: e.table,
+                cause: err,
+            });
+        case '23502':
+            return new NotNullViolationError({
+                column: e.column,
+                table: e.table,
+                cause: err,
+            });
+        case '23514':
+            return new CheckConstraintError({
+                constraint: e.constraint,
+                table: e.table,
+                cause: err,
+            });
+        default:
+            return err;
+    }
+}
+//# sourceMappingURL=errors.js.map

package/dist/generate.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Code generator
+ * turbine-orm — Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
  *   - types.ts     — Entity interfaces, Create/Update input types

package/dist/generate.js

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Code generator
+ * turbine-orm — Code generator
  *
  * Takes an IntrospectedSchema and emits TypeScript files:
  *   - types.ts     — Entity interfaces, Create/Update input types
@@ -8,9 +8,9 @@
  *
  * Output goes to the specified directory (default: ./generated/turbine/).
  */
-import { writeFileSync, mkdirSync } from 'node:fs';
-import { join, resolve, relative } from 'node:path';
-import { snakeToPascal, singularize, } from './schema.js';
+import { mkdirSync, writeFileSync } from 'node:fs';
+import { join, relative, resolve } from 'node:path';
+import { singularize, snakeToPascal } from './schema.js';
 /** Get the TypeScript type name for a table (singularized PascalCase) */
 function entityName(tableName) {
     return snakeToPascal(singularize(tableName));
@@ -52,18 +52,16 @@ export function generate(options) {
 function generatedFileHeader() {
     return [
         '/**',
-        ' * Auto-generated by @batadata/turbine — DO NOT EDIT',
+        ' * Auto-generated by turbine-orm — DO NOT EDIT',
         ' *',
         ` * Generated at: ${new Date().toISOString()}`,
-        ' * @see https://batadata.com/docs/turbine',
+        ' * @see https://turbineorm.dev',
         ' */',
         '',
     ];
 }
 function generateTypes(schema) {
-    const lines = [
-        ...generatedFileHeader(),
-    ];
+    const lines = [...generatedFileHeader()];
     // Generate enum types
     for (const [enumName, labels] of Object.entries(schema.enums)) {
         const typeName = snakeToPascal(enumName);
@@ -113,9 +111,23 @@ function generateTypes(schema) {
         }
         lines.push('};');
         lines.push('');
-        // --- Relation types ---
+        // --- Relations map (for type-safe `with` clauses) ---
         const hasRelations = Object.keys(table.relations).length > 0;
         if (hasRelations) {
+            lines.push(`/** Available relations for the \`${table.name}\` table */`);
+            lines.push(`export interface ${typeName}Relations {`);
+            for (const [relName, rel] of Object.entries(table.relations)) {
+                const targetType = entityName(rel.to);
+                if (rel.type === 'hasMany') {
+                    lines.push(`  ${relName}: ${targetType}[];`);
+                }
+                else {
+                    lines.push(`  ${relName}: ${targetType} | null;`);
+                }
+            }
+            lines.push('}');
+            lines.push('');
+            // --- Legacy per-relation interfaces (kept for backward compatibility) ---
             for (const [relName, rel] of Object.entries(table.relations)) {
                 const targetType = entityName(rel.to);
                 if (rel.type === 'hasMany') {
@@ -142,7 +154,7 @@ function generateTypes(schema) {
 function generateMetadata(schema) {
     const lines = [
         ...generatedFileHeader(),
-        "import type { SchemaMetadata } from '@batadata/turbine';",
+        "import type { SchemaMetadata } from 'turbine-orm';",
         '',
         'export const SCHEMA: SchemaMetadata = {',
         '  tables: {',
@@ -215,12 +227,18 @@ function generateIndex(schema) {
     const tableEntries = Object.values(schema.tables);
     const lines = [
         ...generatedFileHeader(),
-        "import { TurbineClient as BaseTurbineClient, QueryInterface } from '@batadata/turbine';",
-        "import type { TurbineConfig } from '@batadata/turbine';",
+        "import { TurbineClient as BaseTurbineClient, QueryInterface } from 'turbine-orm';",
+        "import type { TurbineConfig } from 'turbine-orm';",
         "import { SCHEMA } from './metadata.js';",
     ];
-    // Import all entity types
-    const typeImports = tableEntries.map((t) => entityName(t.name));
+    // Import all entity types and relations maps
+    const typeImports = [];
+    for (const t of tableEntries) {
+        typeImports.push(entityName(t.name));
+        if (Object.keys(t.relations).length > 0) {
+            typeImports.push(`${entityName(t.name)}Relations`);
+        }
+    }
     lines.push(`import type { ${typeImports.join(', ')} } from './types.js';`);
     lines.push('');
     // Generate the client class with JSDoc
@@ -246,8 +264,10 @@ function generateIndex(schema) {
     for (const table of tableEntries) {
         const typeName = entityName(table.name);
         const accessor = snakeToCamelStr(table.name);
+        const hasRelations = Object.keys(table.relations).length > 0;
+        const genericArgs = hasRelations ? `${typeName}, ${typeName}Relations` : typeName;
         lines.push(`  /** Query interface for the \`${table.name}\` table */`);
-        lines.push(`  declare readonly ${accessor}: QueryInterface<${typeName}>;`);
+        lines.push(`  declare readonly ${accessor}: QueryInterface<${genericArgs}>;`);
     }
     lines.push('');
     lines.push('  constructor(config?: TurbineConfig) {');

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine
+ * turbine-orm
  *
  * Turbine TypeScript SDK — type-safe Postgres queries with nested relations
  * and pipeline batching. Feels like Prisma, runs at raw-SQL speed.
@@ -32,13 +32,15 @@
  * await db.disconnect();
  * ```
  */
-export { TurbineClient, TransactionClient, type TurbineConfig, type TransactionOptions, type Middleware, type MiddlewareParams, type MiddlewareNext, } from './client.js';
-export { QueryInterface, type DeferredQuery, type FindUniqueArgs, type FindManyArgs, type CreateArgs, type CreateManyArgs, type UpdateArgs, type UpdateManyArgs, type DeleteArgs, type DeleteManyArgs, type UpsertArgs, type CountArgs, type GroupByArgs, type AggregateArgs, type AggregateResult, type RelationFilter, type JsonFilter, type ArrayFilter, type WithClause, type WithOptions, type OrderDirection, } from './query.js';
+export { type Middleware, type MiddlewareNext, type MiddlewareParams, type PgCompatPool, type PgCompatPoolClient, type PgCompatQueryResult, TransactionClient, type TransactionOptions, TurbineClient, type TurbineConfig, } from './client.js';
+export { CheckConstraintError, CircularRelationError, ConnectionError, ForeignKeyError, MigrationError, NotFoundError, NotNullViolationError, RelationError, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
+export { type GenerateOptions, generate } from './generate.js';
+export { type IntrospectOptions, introspect } from './introspect.js';
 export { executePipeline, type PipelineResults } from './pipeline.js';
-export type { SchemaMetadata, TableMetadata, ColumnMetadata, RelationDef, IndexMetadata, } from './schema.js';
-export { snakeToCamel, camelToSnake, snakeToPascal, singularize, pgTypeToTs, isDateType, pgArrayType, } from './schema.js';
-export { introspect, type IntrospectOptions } from './introspect.js';
-export { generate, type GenerateOptions } from './generate.js';
-export { defineSchema, table, column, ColumnBuilder, type ColumnDef, type ColumnTypeName, type ColumnConfig, type ColumnType, type TableDef, type SchemaDef, } from './schema-builder.js';
-export { schemaToSQL, schemaToSQLString, schemaDiff, schemaPush, type DiffResult, type AlterDef, type AlterColumnDef, type PushResult, } from './schema-sql.js';
+export { type AggregateArgs, type AggregateResult, type ArrayFilter, type CountArgs, type CreateArgs, type CreateManyArgs, type DeferredQuery, type DeleteArgs, type DeleteManyArgs, type FindManyArgs, type FindManyStreamArgs, type FindUniqueArgs, type GroupByArgs, type JsonFilter, type OrderDirection, QueryInterface, type RelationFilter, type TypedWithClause, type UpdateArgs, type UpdateInput, type UpdateManyArgs, type UpdateOperatorInput, type UpsertArgs, type WithClause, type WithOptions, type WithResult, } from './query.js';
+export type { ColumnMetadata, IndexMetadata, RelationDef, SchemaMetadata, TableMetadata, } from './schema.js';
+export { camelToSnake, isDateType, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
+export { ColumnBuilder, type ColumnConfig, type ColumnDef, type ColumnType, type ColumnTypeName, column, defineSchema, type SchemaDef, type TableDef, table, } from './schema-builder.js';
+export { type AlterColumnDef, type AlterDef, type DiffResult, type PushResult, schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
+export { type TurbineHttpOptions, turbineHttp } from './serverless.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine
+ * turbine-orm
  *
  * Turbine TypeScript SDK — type-safe Postgres queries with nested relations
  * and pipeline batching. Feels like Prisma, runs at raw-SQL speed.
@@ -33,21 +33,25 @@
  * ```
  */
 // Client
-export { TurbineClient, TransactionClient, } from './client.js';
-// Query builder
-export { QueryInterface, } from './query.js';
+export { TransactionClient, TurbineClient, } from './client.js';
+// Error types
+export { CheckConstraintError, CircularRelationError, ConnectionError, ForeignKeyError, MigrationError, NotFoundError, NotNullViolationError, RelationError, TimeoutError, TurbineError, TurbineErrorCode, UniqueConstraintError, ValidationError, wrapPgError, } from './errors.js';
+// Code generation
+export { generate } from './generate.js';
+// Introspection
+export { introspect } from './introspect.js';
 // Pipeline
 export { executePipeline } from './pipeline.js';
+// Query builder
+export { QueryInterface, } from './query.js';
 // Schema utilities
-export { snakeToCamel, camelToSnake, snakeToPascal, singularize, pgTypeToTs, isDateType, pgArrayType, } from './schema.js';
-// Introspection
-export { introspect } from './introspect.js';
-// Code generation
-export { generate } from './generate.js';
+export { camelToSnake, isDateType, pgArrayType, pgTypeToTs, singularize, snakeToCamel, snakeToPascal, } from './schema.js';
 // Schema builder — define schemas in TypeScript
-export { defineSchema, 
+export { ColumnBuilder, column, defineSchema, 
 // Legacy compat (deprecated — use object format with defineSchema)
-table, column, ColumnBuilder, } from './schema-builder.js';
+table, } from './schema-builder.js';
 // Schema SQL — generate DDL, diff, and push
-export { schemaToSQL, schemaToSQLString, schemaDiff, schemaPush, } from './schema-sql.js';
+export { schemaDiff, schemaPush, schemaToSQL, schemaToSQLString, } from './schema-sql.js';
+// Serverless / edge factory
+export { turbineHttp } from './serverless.js';
 //# sourceMappingURL=index.js.map

package/dist/introspect.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Schema introspection
+ * turbine-orm — Schema introspection
  *
  * Connects to a live Postgres database, reads information_schema + pg_catalog,
  * and produces a SchemaMetadata object describing every table, column, relation,

package/dist/introspect.js

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Schema introspection
+ * turbine-orm — Schema introspection
  *
  * Connects to a live Postgres database, reads information_schema + pg_catalog,
  * and produces a SchemaMetadata object describing every table, column, relation,
@@ -8,7 +8,7 @@
  * This is the foundation of `npx turbine generate`.
  */
 import pg from 'pg';
-import { pgTypeToTs, isDateType, pgArrayType, snakeToCamel, singularize, } from './schema.js';
+import { isDateType, pgArrayType, pgTypeToTs, singularize, snakeToCamel, } from './schema.js';
 // ---------------------------------------------------------------------------
 // SQL queries (all parameterized, no interpolation)
 // ---------------------------------------------------------------------------
@@ -99,7 +99,7 @@ export async function introspect(options) {
     });
     try {
         // Run all information_schema queries in parallel
-        const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, enumResult,] = await Promise.all([
+        const [tablesResult, columnsResult, pkResult, fkResult, uniqueResult, indexResult, enumResult] = await Promise.all([
             pool.query(SQL_TABLES, [schema]),
             pool.query(SQL_COLUMNS, [schema]),
             pool.query(SQL_PRIMARY_KEYS, [schema]),
@@ -172,9 +172,7 @@ export async function introspect(options) {
             const isUnique = row.indexdef.includes('UNIQUE');
             // Extract column names from indexdef (e.g. "CREATE INDEX idx ON tbl USING btree (col1, col2)")
             const colMatch = row.indexdef.match(/\((.+)\)/);
-            const columns = colMatch
-                ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, ''))
-                : [];
+            const columns = colMatch ? colMatch[1].split(',').map((c) => c.trim().replace(/ (ASC|DESC)/i, '')) : [];
             indexesByTable.get(row.tablename).push({
                 name: row.indexname,
                 columns,

package/dist/pipeline.d.ts

@@ -1,5 +1,5 @@
 /**
- * @batadata/turbine — Pipeline execution
+ * turbine-orm — Pipeline execution
  *
  * Pipelines batch multiple independent queries into a single database round-trip.
  * Instead of N sequential awaits (N round-trips), you get 1 round-trip for all N queries.