@carno.js/orm 0.2.3

package/dist/domain/reference.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Reference = void 0;
+exports.ref = ref;
+exports.unwrap = unwrap;
+exports.isLoaded = isLoaded;
+exports.refById = refById;
+/**
+ * Creates a reference to an entity.
+ * This is an identity function - it returns the input unchanged.
+ * Useful for explicit ref creation when needed.
+ *
+ * @param entity - The entity to wrap in a reference
+ * @returns The same entity (identity function)
+ *
+ * @example
+ * ```typescript
+ * const user = new User();
+ * const userRef = ref(user); // userRef === user (same reference)
+ * ```
+ */
+function ref(entity) {
+    return entity;
+}
+/**
+ * Unwraps a reference to get the underlying entity.
+ * This is an identity function - it returns the input unchanged.
+ * Provided for API consistency and explicitness.
+ *
+ * @param reference - The reference to unwrap
+ * @returns The underlying entity (same as input)
+ *
+ * @example
+ * ```typescript
+ * const post = await Post.findOne({ id: 1 });
+ * const author = unwrap(post.author); // author === post.author
+ * ```
+ */
+function unwrap(reference) {
+    return reference;
+}
+/**
+ * Type guard to check if a value is not null or undefined.
+ * Useful when working with optional references.
+ *
+ * @param value - The value to check
+ * @returns True if value is not null/undefined
+ *
+ * @example
+ * ```typescript
+ * const post = await Post.findOne({ id: 1 });
+ * if (isLoaded(post.author)) {
+ *   console.log(post.author.name); // TypeScript knows author is defined
+ * }
+ * ```
+ */
+function isLoaded(value) {
+    return value != null;
+}
+/**
+ * @deprecated Use `Ref<T>` type instead. This class is kept for backward compatibility.
+ */
+class Reference {
+    constructor(entity) {
+        this.entity = entity;
+    }
+    get() {
+        return this.entity;
+    }
+}
+exports.Reference = Reference;
+/**
+ * Creates a lightweight entity reference by class and id without hitting the DB.
+ * Useful to assign many-to-one relations when only the id is known.
+ *
+ * Example:
+ *   const library = await UserLibrary.create({
+ *     user: refById(User, userId),
+ *     course: refById(Course, courseId),
+ *   });
+ */
+function refById(Cls, id) {
+    const entity = new Cls();
+    entity.id = id;
+    return entity;
+}

package/dist/driver/bun-driver.base.d.ts

@@ -0,0 +1,72 @@
+import { SQL } from "bun";
+import { ConnectionSettings, DriverInterface, Statement, SnapshotConstraintInfo, ColDiff } from "./driver.interface";
+export declare abstract class BunDriverBase implements Partial<DriverInterface> {
+    protected sql: SQL;
+    connectionString: string;
+    protected readonly poolOptions: {
+        max: number;
+        idleTimeout: number;
+        maxLifetime: number;
+        connectionTimeout: number;
+    };
+    abstract readonly dbType: "postgres" | "mysql";
+    constructor(options: ConnectionSettings);
+    protected buildConnectionString(options: ConnectionSettings): string;
+    protected abstract getProtocol(): string;
+    protected abstract getIdentifierQuote(): string;
+    connect(): Promise<void>;
+    protected buildPoolOptions(options: ConnectionSettings): {
+        max: number;
+        idleTimeout: number;
+        maxLifetime: number;
+        connectionTimeout: number;
+    };
+    private createSqlInstance;
+    protected validateConnection(): Promise<void>;
+    disconnect(): Promise<void>;
+    executeSql(sqlString: string): Promise<any>;
+    private getExecutionContext;
+    transaction<T>(callback: (tx: SQL) => Promise<T>): Promise<T>;
+    protected toDatabaseValue(value: unknown): string | number | boolean;
+    protected escapeString(value: string): string;
+    protected escapeIdentifier(identifier: string): string;
+    protected buildWhereClause(where: string | undefined): string;
+    protected buildOrderByClause(orderBy: string[] | undefined): string;
+    protected buildLimitClause(limit: number | undefined): string;
+    protected buildOffsetClause(offset: number | undefined): string;
+    protected quote(identifier: string): string;
+    protected buildTableIdentifier(schema: string | undefined, tableName: string): string;
+    protected buildColumnConstraints(colDiff: ColDiff): string;
+    protected abstract buildAutoIncrementType(colDiff: ColDiff): string;
+    protected abstract buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
+        beforeSql: string;
+        columnType: string;
+    };
+    protected abstract handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    executeStatement(statement: Statement<any>): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    protected buildInsertSqlWithReturn(statement: Statement<any>): string;
+    protected abstract appendReturningClause(sql: string, statement: Statement<any>): string;
+    protected buildStatementSql(statement: Statement<any>): string;
+    protected buildBaseSql(statement: Statement<any>): string;
+    protected buildInsertSql(table: string, values: any, columns: string[] | undefined, alias: string): string;
+    protected buildUpdateSql(table: string, values: any, alias: string): string;
+    protected buildDeleteSql(table: string, alias: string): string;
+    protected buildJoinClause(statement: Statement<any>): string;
+    protected buildWhereAndOrderClauses(statement: Statement<any>): string;
+    protected buildLimitAndOffsetClause(statement: Statement<any>): string;
+    protected getForeignKeysFromConstraints(constraints: SnapshotConstraintInfo[], row: any, columnNameField: string): any[];
+    protected isForeignKeyConstraint(constraint: SnapshotConstraintInfo, columnName: string): boolean;
+    protected parseForeignKeyDefinition(consDef: string): {
+        referencedColumnName: string;
+        referencedTableName: string;
+    } | null;
+    private escapeRegex;
+}

package/dist/driver/bun-driver.base.js

@@ -0,0 +1,270 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BunDriverBase = void 0;
+const bun_1 = require("bun");
+const transaction_context_1 = require("../transaction/transaction-context");
+class BunDriverBase {
+    constructor(options) {
+        this.connectionString = this.buildConnectionString(options);
+        this.poolOptions = this.buildPoolOptions(options);
+    }
+    buildConnectionString(options) {
+        if (options.connectionString) {
+            return options.connectionString;
+        }
+        const { host, port, username, password, database } = options;
+        const protocol = this.getProtocol();
+        return `${protocol}://${username}:${password}@${host}:${port}/${database}`;
+    }
+    async connect() {
+        if (this.sql) {
+            return;
+        }
+        this.sql = this.createSqlInstance();
+        await this.validateConnection();
+    }
+    buildPoolOptions(options) {
+        return {
+            max: options.max ?? undefined,
+            idleTimeout: options.idleTimeout ?? undefined,
+            maxLifetime: options.maxLifetime ?? undefined,
+            connectionTimeout: options.connectionTimeout ?? undefined,
+        };
+    }
+    createSqlInstance() {
+        return new bun_1.SQL({
+            url: this.connectionString,
+            max: this.poolOptions.max,
+            idleTimeout: this.poolOptions.idleTimeout,
+            maxLifetime: this.poolOptions.maxLifetime,
+            connectionTimeout: this.poolOptions.connectionTimeout,
+        });
+    }
+    async validateConnection() {
+        await this.sql.unsafe("SELECT 1");
+    }
+    async disconnect() {
+        if (!this.sql) {
+            return;
+        }
+        await this.sql.close();
+        this.sql = null;
+    }
+    async executeSql(sqlString) {
+        const context = this.getExecutionContext();
+        return await context.unsafe(sqlString);
+    }
+    getExecutionContext() {
+        const txContext = transaction_context_1.transactionContext.getContext();
+        if (txContext) {
+            return txContext;
+        }
+        if (!this.sql) {
+            throw new Error("Database not connected");
+        }
+        return this.sql;
+    }
+    async transaction(callback) {
+        if (!this.sql) {
+            throw new Error("Database not connected");
+        }
+        return await this.sql.begin(callback);
+    }
+    toDatabaseValue(value) {
+        if (value === null || value === undefined) {
+            return "NULL";
+        }
+        if (value instanceof Date) {
+            return `'${value.toISOString()}'`;
+        }
+        switch (typeof value) {
+            case "string":
+                return `'${this.escapeString(value)}'`;
+            case "number":
+                return value;
+            case "boolean":
+                return value;
+            case "object":
+                return `'${this.escapeString(JSON.stringify(value))}'`;
+            default:
+                return `'${this.escapeString(String(value))}'`;
+        }
+    }
+    escapeString(value) {
+        return value.replace(/'/g, "''");
+    }
+    escapeIdentifier(identifier) {
+        return `"${identifier}"`;
+    }
+    buildWhereClause(where) {
+        if (!where) {
+            return "";
+        }
+        return ` WHERE ${where}`;
+    }
+    buildOrderByClause(orderBy) {
+        if (!orderBy || orderBy.length === 0) {
+            return "";
+        }
+        return ` ORDER BY ${orderBy.join(", ")}`;
+    }
+    buildLimitClause(limit) {
+        if (!limit) {
+            return "";
+        }
+        return ` LIMIT ${limit}`;
+    }
+    buildOffsetClause(offset) {
+        if (!offset) {
+            return "";
+        }
+        return ` OFFSET ${offset}`;
+    }
+    quote(identifier) {
+        const q = this.getIdentifierQuote();
+        return `${q}${identifier}${q}`;
+    }
+    buildTableIdentifier(schema, tableName) {
+        return schema
+            ? `${this.quote(schema)}.${this.quote(tableName)}`
+            : this.quote(tableName);
+    }
+    buildColumnConstraints(colDiff) {
+        const parts = [];
+        if (!colDiff.colChanges?.nullable) {
+            parts.push("NOT NULL");
+        }
+        if (colDiff.colChanges?.primary) {
+            parts.push("PRIMARY KEY");
+        }
+        if (colDiff.colChanges?.unique) {
+            parts.push("UNIQUE");
+        }
+        if (colDiff.colChanges?.default) {
+            parts.push(`DEFAULT ${colDiff.colChanges.default}`);
+        }
+        return parts.length > 0 ? " " + parts.join(" ") : "";
+    }
+    async executeStatement(statement) {
+        const startTime = Date.now();
+        const context = this.getExecutionContext();
+        if (statement.statement === "insert") {
+            const sql = this.buildInsertSqlWithReturn(statement);
+            const result = await context.unsafe(sql);
+            return this.handleInsertReturn(statement, result, sql, startTime);
+        }
+        const sql = this.buildStatementSql(statement);
+        const result = await context.unsafe(sql);
+        return {
+            query: { rows: Array.isArray(result) ? result : [] },
+            startTime,
+            sql,
+        };
+    }
+    buildInsertSqlWithReturn(statement) {
+        const baseSql = this.buildInsertSql(statement.table, statement.values, statement.columns, statement.alias);
+        return this.appendReturningClause(baseSql, statement);
+    }
+    buildStatementSql(statement) {
+        let sql = this.buildBaseSql(statement);
+        sql += this.buildJoinClause(statement);
+        sql += this.buildWhereAndOrderClauses(statement);
+        return sql;
+    }
+    buildBaseSql(statement) {
+        const { statement: type, table, columns, values, alias } = statement;
+        switch (type) {
+            case "select":
+                return `SELECT ${columns ? columns.join(", ") : "*"} FROM ${table} ${alias}`;
+            case "insert":
+                return this.buildInsertSql(table, values, columns, alias);
+            case "update":
+                return this.buildUpdateSql(table, values, alias);
+            case "delete":
+                return this.buildDeleteSql(table, alias);
+            case "count":
+                return `SELECT COUNT(*) as count FROM ${table} ${alias}`;
+            default:
+                return "";
+        }
+    }
+    buildInsertSql(table, values, columns, alias) {
+        const q = this.getIdentifierQuote();
+        const fields = Object.keys(values)
+            .map((v) => `${q}${v}${q}`)
+            .join(", ");
+        const vals = Object.values(values)
+            .map((value) => this.toDatabaseValue(value))
+            .join(", ");
+        return `INSERT INTO ${table} (${fields}) VALUES (${vals})`;
+    }
+    buildUpdateSql(table, values, alias) {
+        const sets = Object.entries(values)
+            .map(([key, value]) => `${key} = ${this.toDatabaseValue(value)}`)
+            .join(", ");
+        return `UPDATE ${table} as ${alias} SET ${sets}`;
+    }
+    buildDeleteSql(table, alias) {
+        return `DELETE FROM ${table} AS ${alias}`;
+    }
+    buildJoinClause(statement) {
+        if (!statement.join)
+            return "";
+        return statement.join
+            .map((join) => {
+            const table = `${join.joinSchema}.${join.joinTable}`;
+            return ` ${join.type} JOIN ${table} ${join.joinAlias} ON ${join.on}`;
+        })
+            .join("");
+    }
+    buildWhereAndOrderClauses(statement) {
+        if (statement.statement === "insert")
+            return "";
+        let sql = this.buildWhereClause(statement.where);
+        sql += this.buildOrderByClause(statement.orderBy);
+        sql += this.buildLimitAndOffsetClause(statement);
+        return sql;
+    }
+    buildLimitAndOffsetClause(statement) {
+        const { offset, limit } = statement;
+        if (offset && limit) {
+            return this.buildOffsetClause(offset) + this.buildLimitClause(limit);
+        }
+        if (limit) {
+            return this.buildLimitClause(limit);
+        }
+        return "";
+    }
+    getForeignKeysFromConstraints(constraints, row, columnNameField) {
+        const columnName = row[columnNameField];
+        return constraints
+            .filter((c) => this.isForeignKeyConstraint(c, columnName))
+            .map((c) => this.parseForeignKeyDefinition(c.consDef))
+            .filter(Boolean);
+    }
+    isForeignKeyConstraint(constraint, columnName) {
+        return (constraint.type === "FOREIGN KEY" &&
+            constraint.consDef.includes(columnName));
+    }
+    parseForeignKeyDefinition(consDef) {
+        const quote = this.getIdentifierQuote();
+        const escapedQuote = this.escapeRegex(quote);
+        const pattern = new RegExp(`REFERENCES\\s+(?:${escapedQuote}([^${escapedQuote}]+)${escapedQuote}|([\\w.]+))\\s*\\(([^)]+)\\)`, "i");
+        const match = consDef.match(pattern);
+        if (!match)
+            return null;
+        const tableName = (match[1] || match[2]).trim();
+        const columnName = match[3]
+            .split(",")[0]
+            .trim()
+            .replace(new RegExp(escapedQuote, "g"), "");
+        return {
+            referencedColumnName: columnName,
+            referencedTableName: tableName,
+        };
+    }
+    escapeRegex(str) {
+        return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    }
+}
+exports.BunDriverBase = BunDriverBase;

package/dist/driver/bun-mysql.driver.d.ts

@@ -0,0 +1,53 @@
+import { ColDiff, ConnectionSettings, DriverInterface, ForeignKeyInfo, IndexStatement, SnapshotConstraintInfo, SnapshotIndexInfo, SnapshotTable, Statement } from './driver.interface';
+import { BunDriverBase } from './bun-driver.base';
+export declare class BunMysqlDriver extends BunDriverBase implements DriverInterface {
+    readonly dbType: "mysql";
+    constructor(options: ConnectionSettings);
+    protected getProtocol(): string;
+    protected getIdentifierQuote(): string;
+    protected buildAutoIncrementType(colDiff: ColDiff): string;
+    protected buildEnumType(schema: string | undefined, tableName: string, colDiff: ColDiff): {
+        beforeSql: string;
+        columnType: string;
+    };
+    protected appendReturningClause(sql: string, statement: Statement<any>): string;
+    protected handleInsertReturn(statement: Statement<any>, result: any, sql: string, startTime: number): Promise<{
+        query: any;
+        startTime: number;
+        sql: string;
+    }>;
+    protected buildLimitAndOffsetClause(statement: Statement<any>): string;
+    getCreateTableInstruction(schema: string | undefined, tableName: string, creates: ColDiff[]): string;
+    getAlterTableFkInstruction(schema: string | undefined, tableName: string, colDiff: ColDiff, fk: ForeignKeyInfo): string;
+    getCreateIndex(index: IndexStatement, schema: string | undefined, tableName: string): string;
+    getAddColumn(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff, colDiffInstructions: string[]): void;
+    getDropColumn(colDiffInstructions: string[], schema: string | undefined, tableName: string, colName: string): void;
+    getDropIndex(index: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getCreateUniqueConstraint(unique: {
+        name: string;
+        properties?: string[];
+    }, schema: string | undefined, tableName: string): string;
+    getDropUniqueConstraint(unique: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    getAlterTableType(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableDefaultInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTablePrimaryKeyInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getDropConstraint(param: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    getAddUniqueConstraint(schema: string | undefined, tableName: string, colName: string): string;
+    getAlterTableDropNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableDropNotNullInstruction(schema: string | undefined, tableName: string, colName: string, colDiff: ColDiff): string;
+    getAlterTableEnumInstruction(schema: string, tableName: string, colName: string, colDiff: ColDiff): string;
+    getDropTypeEnumInstruction(param: {
+        name: string;
+    }, schema: string | undefined, tableName: string): string;
+    snapshot(tableName: string, options: any): Promise<SnapshotTable | undefined>;
+    private parseEnumValues;
+    index(tableName: string, options: any): Promise<SnapshotIndexInfo[] | undefined>;
+    constraints(tableName: string, options: any): Promise<SnapshotConstraintInfo[] | undefined>;
+}