turbine-orm 0.4.0 → 0.7.0

package/dist/cjs/schema-builder.js

@@ -0,0 +1,238 @@
+"use strict";
+/**
+ * turbine-orm — Schema Builder
+ *
+ * TypeScript-first schema definition API. Define your database schema
+ * as plain objects — no method chaining, no DSL. Fully type-checked,
+ * JSON-serializable, and easy to read.
+ *
+ * @example
+ * ```ts
+ * import { defineSchema } from 'turbine-orm';
+ *
+ * export default defineSchema({
+ *   users: {
+ *     id:        { type: 'serial', primaryKey: true },
+ *     email:     { type: 'text', unique: true, notNull: true },
+ *     name:      { type: 'text', notNull: true },
+ *     bio:       { type: 'text' },
+ *     role:      { type: 'varchar', maxLength: 50, default: "'user'" },
+ *     orgId:     { type: 'bigint', notNull: true, references: 'organizations.id' },
+ *     createdAt: { type: 'timestamp', default: 'now()' },
+ *   },
+ * });
+ * ```
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.camelToSnake = exports.column = exports.ColumnBuilder = void 0;
+exports.defineSchema = defineSchema;
+exports.table = table;
+/** Maps shorthand names to actual Postgres type strings */
+const TYPE_MAP = {
+    serial: 'BIGSERIAL',
+    bigint: 'BIGINT',
+    integer: 'INTEGER',
+    smallint: 'SMALLINT',
+    text: 'TEXT',
+    varchar: 'VARCHAR',
+    boolean: 'BOOLEAN',
+    timestamp: 'TIMESTAMPTZ',
+    date: 'DATE',
+    json: 'JSONB',
+    uuid: 'UUID',
+    real: 'REAL',
+    double: 'DOUBLE PRECISION',
+    numeric: 'NUMERIC',
+    bytea: 'BYTEA',
+};
+/** Convert a user-facing ColumnDef to the internal ColumnConfig */
+function resolveColumn(def) {
+    if (!(def.type in TYPE_MAP)) {
+        throw new Error(`Invalid column type "${def.type}". Valid types: ${Object.keys(TYPE_MAP).join(', ')}`);
+    }
+    return {
+        type: TYPE_MAP[def.type],
+        isPrimaryKey: def.primaryKey ?? false,
+        isNotNull: def.notNull ?? false,
+        isNullable: def.nullable ?? false,
+        isUnique: def.unique ?? false,
+        defaultValue: def.default ?? null,
+        referencesTarget: def.references ?? null,
+        maxLength: def.maxLength ?? null,
+    };
+}
+/** Check if a value is a TableDef (from legacy table() builder) */
+function isTableDef(v) {
+    return typeof v === 'object' && v !== null && 'columns' in v && 'name' in v;
+}
+/**
+ * Define the full database schema using plain objects.
+ *
+ * @example
+ * ```ts
+ * export default defineSchema({
+ *   users: {
+ *     id:    { type: 'serial', primaryKey: true },
+ *     email: { type: 'text', unique: true, notNull: true },
+ *     name:  { type: 'text', notNull: true },
+ *   },
+ *   posts: {
+ *     id:     { type: 'serial', primaryKey: true },
+ *     userId: { type: 'bigint', notNull: true, references: 'users.id' },
+ *     title:  { type: 'text', notNull: true },
+ *   },
+ * });
+ * ```
+ */
+function defineSchema(input) {
+    const tables = {};
+    for (const [tableName, value] of Object.entries(input)) {
+        if (isTableDef(value)) {
+            // Legacy format: defineSchema({ users: table({ ... }) })
+            value.name = tableName;
+            tables[tableName] = value;
+        }
+        else {
+            // Object format: defineSchema({ users: { id: { type: 'serial' }, ... } })
+            const columns = {};
+            for (const [fieldName, def] of Object.entries(value)) {
+                columns[fieldName] = resolveColumn(def);
+            }
+            tables[tableName] = { name: tableName, columns };
+        }
+    }
+    return { tables };
+}
+// ---------------------------------------------------------------------------
+// Legacy compat — ColumnBuilder still works for existing code
+// ---------------------------------------------------------------------------
+class ColumnBuilder {
+    _config;
+    constructor() {
+        this._config = {
+            type: 'TEXT',
+            isPrimaryKey: false,
+            isNotNull: false,
+            isNullable: false,
+            isUnique: false,
+            defaultValue: null,
+            referencesTarget: null,
+            maxLength: null,
+        };
+    }
+    serial() {
+        this._config.type = 'BIGSERIAL';
+        return this;
+    }
+    bigint() {
+        this._config.type = 'BIGINT';
+        return this;
+    }
+    integer() {
+        this._config.type = 'INTEGER';
+        return this;
+    }
+    smallint() {
+        this._config.type = 'SMALLINT';
+        return this;
+    }
+    text() {
+        this._config.type = 'TEXT';
+        return this;
+    }
+    varchar(length) {
+        this._config.type = 'VARCHAR';
+        this._config.maxLength = length;
+        return this;
+    }
+    boolean() {
+        this._config.type = 'BOOLEAN';
+        return this;
+    }
+    timestamp() {
+        this._config.type = 'TIMESTAMPTZ';
+        return this;
+    }
+    date() {
+        this._config.type = 'DATE';
+        return this;
+    }
+    json() {
+        this._config.type = 'JSONB';
+        return this;
+    }
+    uuid() {
+        this._config.type = 'UUID';
+        return this;
+    }
+    real() {
+        this._config.type = 'REAL';
+        return this;
+    }
+    doublePrecision() {
+        this._config.type = 'DOUBLE PRECISION';
+        return this;
+    }
+    numeric() {
+        this._config.type = 'NUMERIC';
+        return this;
+    }
+    bytea() {
+        this._config.type = 'BYTEA';
+        return this;
+    }
+    primaryKey() {
+        this._config.isPrimaryKey = true;
+        return this;
+    }
+    notNull() {
+        this._config.isNotNull = true;
+        return this;
+    }
+    nullable() {
+        this._config.isNullable = true;
+        return this;
+    }
+    unique() {
+        this._config.isUnique = true;
+        return this;
+    }
+    default(val) {
+        this._config.defaultValue = val;
+        return this;
+    }
+    references(target) {
+        this._config.referencesTarget = target;
+        return this;
+    }
+    build() {
+        return { ...this._config };
+    }
+}
+exports.ColumnBuilder = ColumnBuilder;
+/** @deprecated Use defineSchema() with plain objects instead */
+exports.column = new Proxy({}, {
+    get(_target, prop) {
+        if (prop === 'varchar')
+            return (length) => new ColumnBuilder().varchar(length);
+        return () => {
+            const builder = new ColumnBuilder();
+            if (typeof builder[prop] === 'function')
+                return builder[prop].call(builder);
+            throw new Error(`Unknown column type: ${prop}`);
+        };
+    },
+});
+/** @deprecated Use defineSchema() with plain objects instead */
+function table(columns) {
+    const built = {};
+    for (const [fieldName, builder] of Object.entries(columns)) {
+        built[fieldName] = builder.build();
+    }
+    return { name: '', columns: built };
+}
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+var schema_js_1 = require("./schema.js");
+Object.defineProperty(exports, "camelToSnake", { enumerable: true, get: function () { return schema_js_1.camelToSnake; } });