@tstdl/base 0.91.50 → 0.91.52

package/orm/repository.js

@@ -5,22 +5,77 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { drizzle } from 'drizzle-orm/node-postgres';
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+import { count, eq, inArray, sql } from 'drizzle-orm';
+import { PgTransaction as DrizzlePgTransaction } from 'drizzle-orm/pg-core';
 import { NotFoundError } from '../errors/not-found.error.js';
-import { NotImplementedError } from '../errors/not-implemented.error.js';
-import { NotSupportedError } from '../errors/not-supported.error.js';
 import { Singleton } from '../injector/decorators.js';
-import { inject } from '../injector/inject.js';
-import { injectionToken } from '../injector/token.js';
-import { assertDefinedPass, isUndefined } from '../utils/type-guards.js';
-import { count, eq, inArray, sql, SQL } from 'drizzle-orm';
-import { getDrizzleTableFromType } from './drizzle/schema-converter.js';
+import { inject, injectArgument } from '../injector/inject.js';
+import { Schema } from '../schema/schema.js';
+import { toArray } from '../utils/array/array.js';
+import { fromDeepObjectEntries } from '../utils/object/object.js';
+import { assertDefinedPass, assertNotNullPass, isNotNull, isUndefined } from '../utils/type-guards.js';
+import { Database } from './database.js';
+import { getColumnDefinitions, getDrizzleTableFromType } from './drizzle/schema-converter.js';
+import { convertQuery } from './query-converter.js';
+import { DrizzleTransaction } from './transaction.js';
 export const repositoryType = Symbol('repositoryType');
-export const entityType = injectionToken('Entity type');
+export class EntityRepositoryConfig {
+    schema;
+}
+const TRANSACTION_TIMESTAMP = sql `transaction_timestamp()`;
 let EntityRepository = class EntityRepository {
-    type = inject(entityType);
-    schema = getDrizzleTableFromType('', this.type);
-    database = drizzle('');
+    #repositoryConstructor;
+    #withTransactionCache = new WeakMap();
+    type;
+    table;
+    columnDefinitions;
+    columnDefinitionsMap;
+    session;
+    isInTransaction;
+    get tx() {
+        return this.session;
+    }
+    constructor(type, table, columnDefinitions, columnDefinitionsMap, session) {
+        this.#repositoryConstructor = new.target;
+        this.type = type ?? injectArgument(this);
+        this.table = table ?? getDrizzleTableFromType(this.type, inject(EntityRepositoryConfig).schema);
+        this.columnDefinitions = columnDefinitions ?? getColumnDefinitions(this.table);
+        this.columnDefinitionsMap = columnDefinitionsMap ?? new Map(this.columnDefinitions.map((column) => [column.objectPath.path, column]));
+        this.session = session ?? inject(Database);
+        this.isInTransaction = this.session instanceof DrizzlePgTransaction;
+    }
+    withOptionalTransaction(transaction) {
+        if (isUndefined(transaction)) {
+            return this;
+        }
+        return this.withTransaction(transaction);
+    }
+    withTransaction(transaction) {
+        if (this.#withTransactionCache.has(transaction)) {
+            return this.#withTransactionCache.get(transaction);
+        }
+        const repositoryWithTransaction = new this.#repositoryConstructor(this.type, this.table, this.columnDefinitions, this.columnDefinitionsMap, transaction.transaction);
+        this.#withTransactionCache.set(transaction, repositoryWithTransaction);
+        return repositoryWithTransaction;
+    }
+    async startTransaction(config) {
+        return DrizzleTransaction.create(this.session, config);
+    }
+    async useTransaction(transaction, handler) {
+        if (isUndefined(transaction)) {
+            return this.transaction(handler);
+        }
+        const repository = this.withTransaction(transaction);
+        return transaction.use(async () => handler(repository, transaction));
+    }
+    async transaction(handler, config) {
+        const transaction = await DrizzleTransaction.create(this.session, config);
+        const repository = this.withTransaction(transaction);
+        return transaction.use(async () => handler(repository, transaction));
+    }
     async load(id) {
         const entity = await this.tryLoad(id);
         if (isUndefined(entity)) {
@@ -29,7 +84,7 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryLoad(id) {
-        return this.tryLoadByQuery(eq(this.schema.id, id));
+        return this.tryLoadByQuery(eq(this.table.id, id));
     }
     async loadByQuery(query, options) {
         const entity = await this.tryLoadByQuery(query, options);
@@ -39,90 +94,337 @@ let EntityRepository = class EntityRepository {
         return entity;
     }
     async tryLoadByQuery(query, options) {
-        if (!(query instanceof SQL)) {
-            throw new NotSupportedError();
-        }
-        const dbQuery = this.database.select()
-            .from(this.schema)
-            .where(query)
+        const sqlQuery = this.convertQuery(query);
+        const dbQuery = this.session.select()
+            .from(this.table)
+            .where(sqlQuery)
             .offset(options?.offset);
-        const [entity] = (await dbQuery);
-        return entity;
+        const [row] = await dbQuery;
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        return this.mapToEntity(row);
     }
     async loadMany(ids, options) {
-        return this.loadManyByQuery(inArray(this.schema.id, ids), options);
+        return this.loadManyByQuery(inArray(this.table.id, ids), options);
     }
     async *loadManyCursor(ids, options) {
         const entities = await this.loadMany(ids, options);
         yield* entities;
     }
     async loadManyByQuery(query, options) {
-        if (!(query instanceof SQL)) {
-            throw new NotSupportedError();
-        }
-        const dbQuery = this.database.select()
-            .from(this.schema)
-            .where(query)
+        const sqlQuery = this.convertQuery(query);
+        const rows = await this.session.select()
+            .from(this.table)
+            .where(sqlQuery)
             .offset(options?.offset)
             .limit(options?.limit);
-        return dbQuery;
+        return rows.map((entity) => this.mapToEntity(entity));
     }
     async *loadManyByQueryCursor(query, options) {
         const entities = await this.loadManyByQuery(query, options);
         yield* entities;
     }
     async loadAll(options) {
-        return this.loadManyByQuery(undefined, options);
+        return this.loadManyByQuery({}, options);
     }
     async *loadAllCursor(options) {
         const entities = await this.loadAll(options);
         yield* entities;
     }
     async count() {
-        const dbQuery = this.database
+        const dbQuery = this.session
             .select({ count: count() })
-            .from(this.schema);
+            .from(this.table);
         const [result] = await dbQuery;
         return assertDefinedPass(result).count;
     }
     async countByQuery(query) {
-        if (!(query instanceof SQL)) {
-            throw new NotSupportedError();
-        }
-        const dbQuery = this.database
+        const sqlQuery = this.convertQuery(query);
+        const dbQuery = this.session
             .select({ count: count() })
-            .from(this.schema)
-            .where(query);
+            .from(this.table)
+            .where(sqlQuery);
         const [result] = await dbQuery;
         return assertDefinedPass(result).count;
     }
     async has(id) {
-        return this.hasByQuery(eq(this.schema.id, id));
+        return this.hasByQuery(eq(this.table.id, id));
     }
     async hasByQuery(query) {
-        // SELECT EXISTS(SELECT 1 FROM contact WHERE id=12) as exists
-        if (!(query instanceof SQL)) {
-            throw new NotSupportedError();
-        }
-        const dbQuery = this.database
-            .select({
-            exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.schema} WHERE ${query})`
-        })
-            .from(this.schema)
-            .where(query);
+        const sqlQuery = this.convertQuery(query);
+        const dbQuery = this.session
+            .select({ exists: sql `SELECT EXISTS(SELECT 1 FROM ${this.table} WHERE ${sqlQuery})` })
+            .from(this.table);
         const [result] = await dbQuery;
         return assertDefinedPass(result).exists;
     }
     async hasAll(ids) {
-        const result = await this.database.execute(sql `SELECT array_agg(id) @> ${ids} AS contains FROM ${this.schema};`);
-        return assertDefinedPass(result.rows[0]).contains;
+        const result = await this.session
+            .select({ contains: sql `array_agg(${this.table.id}) @> ${ids}`.as('contains') })
+            .from(this.table);
+        return assertDefinedPass(result[0]).contains;
+    }
+    async insert(entity) {
+        const columns = this.mapToInsertColumns(entity);
+        const [row] = await this.session
+            .insert(this.table)
+            .values(columns)
+            .returning();
+        return this.mapToEntity(row);
+    }
+    async insertMany(entities) {
+        const columns = entities.map((entity) => this.mapToInsertColumns(entity));
+        const rows = await this.session.insert(this.table).values(columns).returning();
+        return rows.map((row) => this.mapToEntity(row));
+    }
+    async upsert(target, entity, update) {
+        const targetColumns = toArray(target).map((path) => {
+            const columnName = assertDefinedPass(this.columnDefinitionsMap.get(path), `Could not map ${path} to column.`).name;
+            return this.table[columnName];
+        });
+        const columns = this.mapToInsertColumns(entity);
+        const mappedUpdate = this.mapUpdate(update ?? entity);
+        const [row] = await this.session
+            .insert(this.table)
+            .values(columns)
+            .onConflictDoUpdate({
+            target: targetColumns,
+            set: mappedUpdate
+        })
+            .returning();
+        return this.mapToEntity(row);
+    }
+    async upsertMany(target, entities, update) {
+        const targetColumns = toArray(target).map((path) => {
+            const columnName = assertDefinedPass(this.columnDefinitionsMap.get(path), `Could not map ${path} to column.`).name;
+            return this.table[columnName];
+        });
+        const columns = entities.map((entity) => this.mapToColumns(entity));
+        const mappedUpdate = this.mapUpdate(update);
+        const rows = await this.session
+            .insert(this.table)
+            .values(columns)
+            .onConflictDoUpdate({
+            target: targetColumns,
+            set: mappedUpdate
+        })
+            .returning();
+        return rows.map((row) => this.mapToEntity(row));
+    }
+    async update(id, update) {
+        const entity = await this.tryUpdate(id, update);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+        }
+        return entity;
+    }
+    async tryUpdate(id, update) {
+        const mappedUpdate = this.mapUpdate(update);
+        const [row] = await this.session
+            .update(this.table)
+            .set(mappedUpdate)
+            .where(eq(this.table.id, id))
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        return this.mapToEntity(row);
+    }
+    async updateByQuery(query, update) {
+        const entity = await this.tryUpdateByQuery(query, update);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} not found.`);
+        }
+        return entity;
+    }
+    async tryUpdateByQuery(query, update) {
+        const mappedUpdate = this.mapUpdate(update);
+        const idQuery = this.getIdLimitQuery(query);
+        const [row] = await this.session
+            .with(idQuery)
+            .update(this.table)
+            .set(mappedUpdate)
+            .where(inArray(this.table.id, idQuery))
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        return this.mapToEntity(row);
+    }
+    async updateMany(ids, update) {
+        return this.updateManyByQuery(inArray(this.table.id, ids), update);
     }
-    async insert(_entity) {
-        // await this.database.insert(this.schema).values([entity as T]);
-        throw new NotImplementedError();
+    async updateManyByQuery(query, update) {
+        const sqlQuery = this.convertQuery(query);
+        const mappedUpdate = this.mapUpdate(update);
+        const rows = await this.session
+            .update(this.table)
+            .set(mappedUpdate)
+            .where(sqlQuery)
+            .returning();
+        return rows.map((entity) => this.mapToEntity(entity));
+    }
+    async delete(id, metadataUpdate) {
+        const entity = await this.tryDelete(id, metadataUpdate);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+        }
+        return entity;
+    }
+    async tryDelete(id, metadataUpdate) {
+        const [row] = await this.session
+            .update(this.table)
+            .set({
+            deleteTimestamp: TRANSACTION_TIMESTAMP,
+            attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
+        })
+            .where(eq(this.table.id, id))
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        return this.mapToEntity(row);
+    }
+    async deleteByQuery(query, metadataUpdate) {
+        const entity = await this.tryDeleteByQuery(query, metadataUpdate);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} not found.`);
+        }
+        return entity;
+    }
+    async tryDeleteByQuery(query, metadataUpdate) {
+        const idQuery = this.getIdLimitQuery(query);
+        const [row] = await this.session
+            .update(this.table)
+            .set({
+            deleteTimestamp: TRANSACTION_TIMESTAMP,
+            attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
+        })
+            .where(inArray(this.table.id, idQuery))
+            .returning();
+        if (isUndefined(row)) {
+            return undefined;
+        }
+        return this.mapToEntity(row);
+    }
+    async deleteMany(ids, metadataUpdate) {
+        return this.deleteManyByQuery(inArray(this.table.id, ids), metadataUpdate);
+    }
+    async deleteManyByQuery(query, metadataUpdate) {
+        const sqlQuery = this.convertQuery(query);
+        const rows = await this.session
+            .update(this.table)
+            .set({
+            deleteTimestamp: TRANSACTION_TIMESTAMP,
+            attributes: this.getAttributesUpdate(metadataUpdate?.attributes)
+        })
+            .where(sqlQuery)
+            .returning();
+        return rows.map((row) => this.mapToEntity(row));
+    }
+    async hardDelete(id) {
+        const result = await this.tryHardDelete(id);
+        if (!result) {
+            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+        }
+    }
+    async tryHardDelete(id) {
+        const result = await this.session.delete(this.table).where(eq(this.table.id, id));
+        console.log({ deleteResult: result });
+        return isNotNull(result.rowCount) && (result.rowCount > 0);
+    }
+    async hardDeleteByQuery(query) {
+        const idQuery = this.getIdLimitQuery(query);
+        const result = await this.session
+            .with(idQuery)
+            .delete(this.table)
+            .where(inArray(this.table.id, idQuery));
+        console.log({ deleteResult: result });
+        return isNotNull(result.rowCount) && (result.rowCount > 0);
+    }
+    async hardDeleteMany(ids) {
+        return this.hardDeleteManyByQuery(inArray(this.table.id, ids));
+    }
+    async hardDeleteManyByQuery(query) {
+        const sqlQuery = this.convertQuery(query);
+        const result = await this.session.delete(this.table).where(sqlQuery);
+        console.log({ deleteResult: result });
+        return assertNotNullPass(result.rowCount);
+    }
+    convertQuery(query) {
+        return convertQuery(query, this.table, this.columnDefinitionsMap);
+    }
+    mapToEntity(columns) {
+        const entries = this.columnDefinitions.map((def) => [def.objectPath, columns[def.name]]);
+        const obj = fromDeepObjectEntries(entries);
+        return Schema.parse(this.type, obj);
+    }
+    mapToColumns(obj) {
+        const columns = {};
+        for (const def of this.columnDefinitions) {
+            columns[def.name] = def.dereferenceObjectPath(obj);
+        }
+        return columns;
+    }
+    mapToInsertColumns(obj) {
+        const mapped = this.mapToColumns(obj);
+        return {
+            ...mapped,
+            revision: 1,
+            revisionTimestamp: TRANSACTION_TIMESTAMP,
+            createTimestamp: TRANSACTION_TIMESTAMP
+        };
+    }
+    mapUpdate(update) {
+        const mappedUpdate = {};
+        for (const column of this.columnDefinitions) {
+            const value = column.dereferenceObjectPath(update);
+            if (isUndefined(value)) {
+                continue;
+            }
+            mappedUpdate[column.name] = value;
+        }
+        return {
+            ...mappedUpdate,
+            attributes: this.getAttributesUpdate(update.metadata?.attributes),
+            revision: sql `${this.table.revision} + 1`,
+            revisionTimestamp: sql `transaction_timestamp()`
+        };
+    }
+    getIdLimitQuery(query) {
+        const sqlQuery = this.convertQuery(query);
+        return this.session.$with('id').as(this.session.select({ id: this.table.id })
+            .from(this.table)
+            .where(sqlQuery)
+            .limit(1));
+    }
+    getAttributesUpdate(attributes) {
+        if (isUndefined(attributes)) {
+            return undefined;
+        }
+        return sql `${this.table.attributes} || '${JSON.stringify(attributes)}'::jsonb`;
     }
 };
 EntityRepository = __decorate([
-    Singleton()
+    Singleton({
+        provider: {
+            useFactory: () => new EntityRepository()
+        }
+    }),
+    __metadata("design:paramtypes", [Object, Object, Array, Map, Object])
 ], EntityRepository);
 export { EntityRepository };
+export function injectRepository(type) {
+    return inject((EntityRepository), type);
+}
+export function getRepository(type, config) {
+    const className = `${type.name}Service`;
+    const entityRepositoryClass = {
+        [className]: class extends EntityRepository {
+        }
+    }[className];
+    const injectorDecorator = Singleton({ providers: [{ provide: EntityRepositoryConfig, useValue: config }] });
+    injectorDecorator(entityRepositoryClass);
+    return entityRepositoryClass;
+}

package/orm/schemas/index.d.ts

@@ -1 +1,4 @@
+export * from './json.js';
+export * from './numeric-date.js';
+export * from './timestamp.js';
 export * from './uuid.js';

package/orm/schemas/index.js

@@ -1 +1,4 @@
+export * from './json.js';
+export * from './numeric-date.js';
+export * from './timestamp.js';
 export * from './uuid.js';

package/orm/schemas/json.d.ts

@@ -0,0 +1,9 @@
+import { type Decorator } from '../../reflection/index.js';
+import { ObjectSchema, type ObjectSchemaOptions, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+export type JsonSchemaOptions = Pick<ObjectSchemaOptions, 'factory'>;
+export declare class JsonSchema extends ObjectSchema {
+    readonly name = "Json";
+    constructor(options?: JsonSchemaOptions);
+}
+export declare function json(options?: JsonSchemaOptions): JsonSchema;
+export declare function Json(options?: JsonSchemaOptions & SchemaPropertyDecoratorOptions): Decorator<'class' | 'property' | 'accessor'>;

package/orm/schemas/json.js

@@ -0,0 +1,19 @@
+import { createDecorator } from '../../reflection/index.js';
+import { any, Class, ObjectSchema, Property } from '../../schema/index.js';
+export class JsonSchema extends ObjectSchema {
+    name = 'Json';
+    constructor(options) {
+        super({}, { ...options, unknownPropertiesKey: any(), unknownProperties: any() });
+    }
+}
+export function json(options) {
+    return new JsonSchema(options);
+}
+export function Json(options) {
+    return createDecorator({ class: true, property: true, accessor: true }, (data, metadata, args) => {
+        if (data.type == 'class') {
+            return Class({ schema: json({ factory: { type: data.constructor } }) })(args[0]);
+        }
+        return Property(json({ factory: { type: metadata.type } }), options)(args[0], args[1], args[2]);
+    });
+}

package/orm/schemas/numeric-date.d.ts

@@ -0,0 +1,8 @@
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions, type SimpleSchemaOptions } from '../../schema/index.js';
+export type NumericDateSchemaOptions = SimpleSchemaOptions & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
+export declare class NumericDateSchema extends NumberSchema {
+    readonly name = "NumericDate";
+    constructor(options?: NumericDateSchemaOptions);
+}
+export declare function numericDate(options?: NumericDateSchemaOptions): NumericDateSchema;
+export declare function NumericDate(options?: NumericDateSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/numeric-date.js

@@ -0,0 +1,13 @@
+import { NumberSchema, Property } from '../../schema/index.js';
+export class NumericDateSchema extends NumberSchema {
+    name = 'NumericDate';
+    constructor(options) {
+        super({ ...options, integer: true });
+    }
+}
+export function numericDate(options) {
+    return new NumericDateSchema(options);
+}
+export function NumericDate(options) {
+    return Property(numericDate(options), options);
+}

package/orm/schemas/timestamp.d.ts

@@ -0,0 +1,10 @@
+import type { JsonPath } from '../../json-path/json-path.js';
+import { NumberSchema, type NumberSchemaOptions, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions, type SchemaTestOptions, type SchemaTestResult, type SimpleSchemaOptions } from '../../schema/index.js';
+export type TimestampSchemaOptions = SimpleSchemaOptions & Pick<NumberSchemaOptions, 'minimum' | 'maximum'>;
+export declare class TimestampSchema extends NumberSchema {
+    readonly name = "Timestamp";
+    constructor(options?: TimestampSchemaOptions);
+    _test(value: any, path: JsonPath, options: SchemaTestOptions): SchemaTestResult<number>;
+}
+export declare function timestamp(options?: TimestampSchemaOptions): TimestampSchema;
+export declare function Timestamp(options?: TimestampSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/timestamp.js

@@ -0,0 +1,20 @@
+import { NumberSchema, Property } from '../../schema/index.js';
+import { isDate } from '../../utils/type-guards.js';
+export class TimestampSchema extends NumberSchema {
+    name = 'Timestamp';
+    constructor(options) {
+        super({ ...options, integer: true });
+    }
+    _test(value, path, options) {
+        if (isDate(value)) {
+            return super._test(value.getTime(), path, options);
+        }
+        return super._test(value, path, options);
+    }
+}
+export function timestamp(options) {
+    return new TimestampSchema(options);
+}
+export function Timestamp(options) {
+    return Property(timestamp(options), options);
+}

package/orm/transaction.d.ts

@@ -0,0 +1,29 @@
+import { DeferredPromise } from '../promise/deferred-promise.js';
+import type { PgTransaction as DrizzlePgTransaction, PgTransactionConfig } from 'drizzle-orm/pg-core';
+import type { Database } from './database.js';
+type PgTransaction = DrizzlePgTransaction<any, any, any>;
+export type TransactionConfig = PgTransactionConfig;
+export declare abstract class Transaction {
+    #private;
+    readonly afterCommit$: import("rxjs").Observable<void>;
+    manualCommit: boolean;
+    withManualCommit(): void;
+    /**
+     * Enters automatic transaction handling. Transaction will be commited when all use-calls are done or rolled back when one throws.
+     */
+    use<T>(handler: () => Promise<T>): Promise<T>;
+    commit(): Promise<void>;
+    rollback(): void;
+    protected abstract _commit(): Promise<void>;
+    protected abstract _rollback(): void;
+}
+export declare class DrizzleTransaction extends Transaction {
+    readonly transaction: PgTransaction;
+    readonly deferPromise: DeferredPromise<void>;
+    readonly pgTransactionPromise: Promise<void>;
+    constructor(transaction: PgTransaction, pgTransactionPromise: Promise<void>);
+    static create(session: Database | PgTransaction, config?: TransactionConfig): Promise<DrizzleTransaction>;
+    protected _commit(): Promise<void>;
+    protected _rollback(): void;
+}
+export {};