@carno.js/orm 0.2.3

package/dist/testing/with-database.js

@@ -0,0 +1,311 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withDatabase = withDatabase;
+const globby_1 = __importDefault(require("globby"));
+const fs_1 = require("fs");
+const path_1 = __importDefault(require("path"));
+const core_1 = require("@carno.js/core");
+const entities_1 = require("../domain/entities");
+const orm_1 = require("../orm");
+const orm_service_1 = require("../orm.service");
+const bun_pg_driver_1 = require("../driver/bun-pg.driver");
+const orm_session_context_1 = require("../orm-session-context");
+const constants_1 = require("../constants");
+const DEFAULT_SCHEMA = 'public';
+const DEFAULT_CONNECTION = {
+    host: 'localhost',
+    port: 5432,
+    database: 'postgres',
+    username: 'postgres',
+    password: 'postgres',
+    driver: bun_pg_driver_1.BunPgDriver,
+};
+const sessionCache = new Map();
+function getCacheKey(options) {
+    const connection = resolveConnection(options.connection);
+    const entitySignature = resolveEntitySignature();
+    return JSON.stringify({
+        host: connection.host,
+        port: connection.port,
+        database: connection.database,
+        schema: options.schema ?? DEFAULT_SCHEMA,
+        entityFile: options.entityFile,
+        migrationPath: connection.migrationPath,
+        entitySignature,
+    });
+}
+function resolveEntitySignature() {
+    const entities = core_1.Metadata.get(constants_1.ENTITIES, Reflect) || [];
+    return buildEntitySignature(entities);
+}
+function buildEntitySignature(entities) {
+    if (entities.length < 1) {
+        return 'none';
+    }
+    const names = entities.map((entity) => entity.target?.name ?? 'unknown');
+    return names.sort().join('|');
+}
+async function withDatabase(arg1, arg2, arg3) {
+    const { routine: targetRoutine, options: targetOptions, statements } = await normalizeArgs(arg1, arg2, arg3);
+    const cacheKey = getCacheKey(targetOptions);
+    let cachedSession = sessionCache.get(cacheKey);
+    const schemaStatements = await resolveSchemaStatements(statements, targetOptions);
+    if (!cachedSession) {
+        const session = await createSession(targetOptions);
+        cachedSession = {
+            orm: session.orm,
+            schema: session.schema,
+            storage: session.storage,
+        };
+        sessionCache.set(cacheKey, cachedSession);
+    }
+    await runWithSession(cachedSession, async () => {
+        const context = buildContext(cachedSession.orm);
+        await dropAndRecreateSchema(context, cachedSession.schema);
+        await prepareSchema(context, cachedSession.schema);
+        await createTables(context, schemaStatements);
+        await targetRoutine(context);
+    });
+}
+async function createSession(options) {
+    const logger = selectLogger(options);
+    const orm = new orm_1.Orm(logger);
+    const storage = new entities_1.EntityStorage();
+    await initializeOrm(orm, storage, options);
+    return { orm, schema: options.schema ?? DEFAULT_SCHEMA, storage };
+}
+function selectLogger(options) {
+    if (options.logger) {
+        return options.logger;
+    }
+    const config = { applicationConfig: { logger: { level: 'info' } } };
+    return new core_1.LoggerService(config);
+}
+async function initializeOrm(orm, storage, options) {
+    if (options.entityFile) {
+        const entityFiles = await (0, globby_1.default)(options.entityFile, { absolute: true });
+        for (const file of entityFiles) {
+            await Promise.resolve(`${file}`).then(s => __importStar(require(s)));
+        }
+    }
+    const service = new orm_service_1.OrmService(orm, storage, options.entityFile);
+    const connection = resolveConnection(options.connection);
+    await service.onInit(connection);
+}
+async function runWithSession(session, routine) {
+    await orm_session_context_1.ormSessionContext.run({ orm: session.orm, storage: session.storage }, routine);
+}
+function resolveConnection(overrides) {
+    if (!overrides) {
+        return DEFAULT_CONNECTION;
+    }
+    return {
+        ...DEFAULT_CONNECTION,
+        ...overrides,
+        driver: overrides.driver ?? bun_pg_driver_1.BunPgDriver,
+    };
+}
+function buildContext(orm) {
+    return {
+        orm,
+        executeSql: (sql) => executeSql(orm, sql),
+    };
+}
+async function executeSql(orm, sql) {
+    if (!orm.driverInstance) {
+        throw new Error('Database driver not initialized. Call withDatabase() before executing SQL.');
+    }
+    const result = await orm.driverInstance.executeSql(sql);
+    return { rows: Array.isArray(result) ? result : [] };
+}
+async function createTables(context, statements) {
+    const payload = statements.filter(Boolean);
+    if (payload.length < 1) {
+        return;
+    }
+    await executeStatements(context, payload);
+}
+async function executeStatements(context, statements) {
+    for (const statement of statements) {
+        await context.executeSql(statement);
+    }
+}
+async function dropAndRecreateSchema(context, schema) {
+    await context.executeSql(`DROP SCHEMA IF EXISTS ${schema} CASCADE; CREATE SCHEMA ${schema};`);
+}
+async function normalizeArgs(tablesOrRoutine, routineOrOptions, optionsOrStatements) {
+    if (Array.isArray(tablesOrRoutine)) {
+        return {
+            routine: routineOrOptions,
+            options: optionsOrStatements ?? {},
+            statements: tablesOrRoutine,
+        };
+    }
+    return {
+        routine: tablesOrRoutine,
+        options: routineOrOptions ?? {},
+        statements: Array.isArray(optionsOrStatements) ? optionsOrStatements : [],
+    };
+}
+async function resolveSchemaStatements(statements, options) {
+    const explicit = statements.filter(Boolean);
+    if (explicit.length > 0) {
+        return explicit;
+    }
+    const fromMigrations = await loadStatementsFromMigrations(options);
+    return fromMigrations.filter(Boolean);
+}
+function normalizeGlobPatterns(patterns) {
+    return patterns.map(normalizeGlobPattern);
+}
+function normalizeGlobPattern(pattern) {
+    return pattern.replace(/\\/g, '/');
+}
+async function loadStatementsFromMigrations(options) {
+    const connection = resolveConnection(options.connection);
+    const patterns = await resolveMigrationPatterns(connection);
+    if (patterns.length < 1) {
+        return [];
+    }
+    const normalizedPatterns = normalizeGlobPatterns(patterns);
+    const files = await (0, globby_1.default)(normalizedPatterns, { absolute: true, expandDirectories: false });
+    if (files.length < 1) {
+        return [];
+    }
+    const orderedFiles = sortMigrationFiles(files);
+    return extractStatementsFromFiles(orderedFiles);
+}
+async function resolveMigrationPatterns(connection) {
+    if (connection.migrationPath) {
+        return [connection.migrationPath];
+    }
+    const inferred = await inferMigrationPathFromConfig();
+    if (inferred) {
+        return [inferred];
+    }
+    return [];
+}
+async function inferMigrationPathFromConfig() {
+    const configFile = await findConfigFile();
+    if (!configFile) {
+        return undefined;
+    }
+    const contents = await safeReadFile(configFile);
+    if (!contents) {
+        return undefined;
+    }
+    return extractMigrationPath(contents, configFile);
+}
+async function findConfigFile() {
+    const candidates = [
+        'carno.config.ts',
+        'carno.config.js',
+        'carno.config.mjs',
+        'carno.config.cjs',
+    ];
+    for (const file of candidates) {
+        const fullPath = path_1.default.resolve(process.cwd(), file);
+        const exists = await fileExists(fullPath);
+        if (exists) {
+            return fullPath;
+        }
+    }
+    return undefined;
+}
+async function fileExists(target) {
+    try {
+        await fs_1.promises.access(target);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function safeReadFile(file) {
+    try {
+        return await fs_1.promises.readFile(file, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function extractMigrationPath(source, file) {
+    const match = source.match(/migrationPath\s*:\s*['"`]([^'"`]+)['"`]/);
+    if (!match) {
+        return undefined;
+    }
+    const candidate = match[1].trim();
+    if (path_1.default.isAbsolute(candidate)) {
+        return candidate;
+    }
+    const baseDir = path_1.default.dirname(file);
+    return path_1.default.resolve(baseDir, candidate);
+}
+async function extractStatementsFromFiles(files) {
+    const statements = [];
+    for (const file of files) {
+        const payload = await safeReadFile(file);
+        if (!payload) {
+            continue;
+        }
+        const extracted = extractStatements(payload);
+        statements.push(...extracted);
+    }
+    return Array.from(new Set(statements));
+}
+function extractStatements(payload) {
+    const matches = payload.match(/(CREATE\s+(?:TABLE|TYPE|INDEX|SCHEMA)[\s\S]*?;|ALTER\s+TABLE[\s\S]*?\bADD\b[\s\S]*?;)/gi) ?? [];
+    return matches.map((statement) => statement.replace(/\s+/g, ' ').trim());
+}
+function sortMigrationFiles(files) {
+    return [...files].sort((first, second) => path_1.default.basename(first).localeCompare(path_1.default.basename(second), undefined, { numeric: true }));
+}
+async function prepareSchema(context, schema) {
+    await context.executeSql(buildCreateSchemaStatement(schema));
+    await ensureSearchPath(context, schema);
+}
+function buildCreateSchemaStatement(schema) {
+    return `CREATE SCHEMA IF NOT EXISTS ${schema};`;
+}
+async function ensureSearchPath(context, schema) {
+    await context.executeSql(buildSearchPathStatement(schema));
+}
+function buildSearchPathStatement(schema) {
+    return `SET search_path TO ${schema};`;
+}

package/dist/transaction/transaction-context.d.ts

@@ -0,0 +1,10 @@
+import { SQL } from 'bun';
+declare class TransactionContextManager {
+    private storage;
+    constructor();
+    run<T>(tx: SQL, callback: () => Promise<T>): Promise<T>;
+    getContext(): SQL | undefined;
+    hasContext(): boolean;
+}
+export declare const transactionContext: TransactionContextManager;
+export {};

package/dist/transaction/transaction-context.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.transactionContext = void 0;
+const async_hooks_1 = require("async_hooks");
+class TransactionContextManager {
+    constructor() {
+        this.storage = new async_hooks_1.AsyncLocalStorage();
+    }
+    run(tx, callback) {
+        return this.storage.run({ tx }, callback);
+    }
+    getContext() {
+        return this.storage.getStore()?.tx;
+    }
+    hasContext() {
+        return this.storage.getStore() !== undefined;
+    }
+}
+exports.transactionContext = new TransactionContextManager();

package/dist/utils/value-processor.d.ts

@@ -0,0 +1,14 @@
+import { Options } from '../domain/entities';
+import { ValueOrInstance } from '../driver/driver.interface';
+export declare class ValueProcessor {
+    static processForInsert<T>(values: Partial<{
+        [K in keyof T]: ValueOrInstance<T[K]>;
+    }>, options: Options): Record<string, any>;
+    static processForUpdate<T>(values: Partial<{
+        [K in keyof T]: ValueOrInstance<T[K]>;
+    }>, options: Options): Record<string, any>;
+    static getColumnName(propertyKey: string, entity: Options): string;
+    static createInstance(values: any, entity: Function, moment?: 'insert' | 'update' | undefined): any;
+    private static isValueObject;
+    private static isBaseEntity;
+}

package/dist/utils/value-processor.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueProcessor = void 0;
+const value_object_1 = require("../common/value-object");
+const base_entity_1 = require("../domain/base-entity");
+const entities_1 = require("../domain/entities");
+const utils_1 = require("../utils");
+class ValueProcessor {
+    static processForInsert(values, options) {
+        const newValue = {};
+        for (const value in values) {
+            const columnName = ValueProcessor.getColumnName(value, options);
+            if (ValueProcessor.isValueObject(values[value])) {
+                newValue[columnName] = values[value].getValue();
+                continue;
+            }
+            if (ValueProcessor.isBaseEntity(values[value])) {
+                // @ts-ignore
+                newValue[columnName] = values[value].id;
+                continue;
+            }
+            newValue[columnName] = values[value];
+        }
+        return newValue;
+    }
+    static processForUpdate(values, options) {
+        const newValue = {};
+        for (const value in values) {
+            const columnName = ValueProcessor.getColumnName(value, options);
+            if (ValueProcessor.isValueObject(values[value])) {
+                newValue[columnName] = values[value].getValue();
+                continue;
+            }
+            if (ValueProcessor.isBaseEntity(values[value])) {
+                // @ts-ignore
+                newValue[columnName] = values[value].id;
+                continue;
+            }
+            newValue[columnName] = values[value];
+        }
+        return newValue;
+    }
+    static getColumnName(propertyKey, entity) {
+        if (propertyKey.startsWith('$')) {
+            return propertyKey;
+        }
+        const property = entity.properties[propertyKey];
+        const relation = entity.relations?.find(rel => rel.propertyKey === propertyKey);
+        if (!property) {
+            if (!relation) {
+                throw new Error('Property not found');
+            }
+            return relation.columnName || propertyKey;
+        }
+        return property.options.columnName || propertyKey;
+    }
+    static createInstance(values, entity, moment = undefined) {
+        const entityStorage = entities_1.EntityStorage.getInstance();
+        const entityOptions = entityStorage.get(entity);
+        const instance = new entity();
+        if (!entityOptions) {
+            throw new Error('Entity not found');
+        }
+        const property = Object.entries(entityOptions.properties);
+        const relations = entityOptions.relations;
+        property.forEach(([key, property]) => {
+            if (property.options.onInsert && moment === 'insert') {
+                instance[key] = property.options.onInsert();
+            }
+            if (property.options.onUpdate && moment === 'update') {
+                instance[key] = property.options.onUpdate();
+            }
+            const columnName = property.options.columnName;
+            if (columnName in values) {
+                instance[key] = values[columnName];
+            }
+        });
+        if (relations) {
+            for (const relation of relations) {
+                if (relation.relation === 'many-to-one') {
+                    instance[relation.propertyKey] = values[relation.columnName];
+                }
+            }
+        }
+        return instance;
+    }
+    static isValueObject(value) {
+        return (0, utils_1.extendsFrom)(value_object_1.ValueObject, value?.constructor?.prototype);
+    }
+    static isBaseEntity(value) {
+        return value instanceof base_entity_1.BaseEntity;
+    }
+}
+exports.ValueProcessor = ValueProcessor;

package/dist/utils.d.ts

@@ -0,0 +1,3 @@
+export declare function getDefaultLength(type: string): number;
+export declare function toSnakeCase(propertyKey1: string): string;
+export declare function extendsFrom(baseClass: any, instance: any): boolean;

package/dist/utils.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultLength = getDefaultLength;
+exports.toSnakeCase = toSnakeCase;
+exports.extendsFrom = extendsFrom;
+function getDefaultLength(type) {
+    return null;
+}
+function toSnakeCase(propertyKey1) {
+    propertyKey1 = propertyKey1[0].toLowerCase() + propertyKey1.slice(1);
+    return propertyKey1.replace(/([A-Z])/g, '_$1').toLowerCase();
+}
+function extendsFrom(baseClass, instance) {
+    if (!instance)
+        return false;
+    let proto = Object.getPrototypeOf(instance);
+    while (proto) {
+        if (proto === baseClass.prototype) {
+            return true;
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+    return false;
+}

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@carno.js/orm",
+  "version": "0.2.3",
+  "description": "A simple ORM for Carno.js.",
+  "type": "commonjs",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./testing": {
+      "types": "./dist/testing/index.d.ts",
+      "require": "./dist/testing/index.js",
+      "default": "./dist/testing/index.js"
+    }
+  },
+  "scripts": {
+    "compile": "rm -rf ./dist tsconfig.tsbuildinfo && tsc --build --force",
+    "build": "tsc --build --force",
+    "prepublishOnly": "bun run build"
+  },
+  "dependencies": {
+    "commander": "^11.1.0",
+    "globby": "^10.0.2",
+    "reflect-metadata": "^0.1.13",
+    "ts-morph": "^27.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+ssh://git@github.com:mlusca/carno.js.git"
+  },
+  "devDependencies": {
+    "@types/uuid": "^9.0.6",
+    "uuid": "^9.0.1"
+  },
+  "peerDependencies": {
+    "@carno.js/core": "^0.2.0"
+  },
+  "author": "",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "carno",
+    "carno.js",
+    "orm",
+    "database",
+    "sql",
+    "postgres",
+    "postgresql",
+    "bun",
+    "value-object"
+  ],
+  "gitHead": "179037d66f41ab7014a008b141afce3c9232190e"
+}