@tstdl/base 0.91.28 → 0.91.31

package/orm/decorators.js

@@ -1,4 +1,23 @@
-import { createPropertyDecorator } from '../reflection/utils.js';
+import { createClassDecorator, createDecorator, createPropertyDecorator } from '../reflection/utils.js';
+import { isArray } from '../utils/type-guards.js';
+export function createTableDecorator(data) {
+    return createClassDecorator({ data: { orm: data }, mergeData: true });
+}
+export function createColumnDecorator(data) {
+    return createPropertyDecorator({ data: { orm: data }, mergeData: true });
+}
+export function createTableAndColumnDecorator(data) {
+    return createDecorator({ class: true, property: true, data: { orm: data }, mergeData: true });
+}
+export function Column(options) {
+    return createColumnDecorator({ ...options });
+}
 export function PrimaryKey() {
-    return createPropertyDecorator({ data: { orm: { primaryKey: true } }, mergeData: true });
+    return createColumnDecorator({ primaryKey: true });
+}
+export function Unique(name, columnsOrOptions, options) {
+    if (isArray(columnsOrOptions)) {
+        return createTableDecorator({ unique: [{ name, columns: columnsOrOptions, options }] });
+    }
+    return createColumnDecorator({ unique: { name, options: columnsOrOptions ?? options } });
 }

package/orm/drizzle/schema-converter.d.ts

@@ -0,0 +1,19 @@
+import type { BuildColumns, NotNull } from 'drizzle-orm';
+import { type PgTableWithColumns } from 'drizzle-orm/pg-core';
+import type { SnakeCase } from 'type-fest';
+import type { Enumeration, Type } from '../../types.js';
+import type { EntityType } from '../entity.js';
+import type { ColumnBuilder } from '../types.js';
+type Column<Name extends string, T> = null extends T ? ColumnBuilder<T, Name> : NotNull<ColumnBuilder<T, Name>>;
+export declare const getDrizzleTableFromType: typeof _getDrizzleTableFromType;
+export type PgTableFromType<S extends string, T extends Type, TableName extends string = T extends EntityType ? SnakeCase<T['entityName']> : string> = PgTableWithColumns<{
+    name: TableName;
+    schema: S;
+    columns: BuildColumns<TableName, {
+        [P in keyof InstanceType<T>]: Column<Extract<P, string>, InstanceType<T>[P]>;
+    }, 'pg'>;
+    dialect: 'pg';
+}>;
+export declare function _getDrizzleTableFromType<S extends string, T extends Type>(schemaName: S, type: T, tableName?: string): PgTableFromType<S, T>;
+export declare function registerEnum(enumeration: Enumeration, name: string): void;
+export {};

package/orm/drizzle/schema-converter.js

@@ -0,0 +1,116 @@
+import { toSnakeCase } from 'drizzle-orm/casing';
+import { boolean, doublePrecision, integer, pgSchema, text, unique, uuid } from 'drizzle-orm/pg-core';
+import { NotSupportedError } from '../../errors/not-supported.error.js';
+import { reflectionRegistry } from '../../reflection/registry.js';
+import { ArraySchema, BooleanSchema, EnumerationSchema, getObjectSchema, NullableSchema, NumberSchema, OptionalSchema, StringSchema } from '../../schema/index.js';
+import { enumValues } from '../../utils/enum.js';
+import { memoize, memoizeSingle } from '../../utils/function/memoize.js';
+import { fromEntries, objectEntries } from '../../utils/object/object.js';
+import { assertDefinedPass, assertStringPass, isArray, isDefined, isString, isUndefined } from '../../utils/type-guards.js';
+import { UuidSchema } from '../schemas/uuid.js';
+const getDbSchema = memoizeSingle(pgSchema);
+export const getDrizzleTableFromType = memoize(_getDrizzleTableFromType);
+export function _getDrizzleTableFromType(schemaName, type, tableName = getDefaultTableName(type)) {
+    const metadata = reflectionRegistry.getMetadata(type);
+    if (isUndefined(metadata)) {
+        throw new Error('Type does not have reflection metadata.');
+    }
+    const dbSchema = getDbSchema(schemaName);
+    const tableReflectionData = metadata.data.tryGet('orm');
+    const objectSchema = getObjectSchema(type);
+    const entries = objectEntries(objectSchema.properties).map(([property, schema]) => {
+        const columnReflectionData = metadata.properties.get(property)?.data.tryGet('orm');
+        const propertyName = columnReflectionData?.name ?? assertStringPass(toSnakeCase(property));
+        return [
+            property,
+            getPostgresColumn(tableName, propertyName, dbSchema, schema, columnReflectionData ?? {})
+        ];
+    });
+    function getColumn(table, propertyName) {
+        return assertDefinedPass(table[propertyName], `Property "${propertyName}" does not exist on ${type.name}`);
+    }
+    const drizzleSchema = dbSchema.table(tableName, fromEntries(entries), (table) => {
+        const uniqueEntries = tableReflectionData?.unique?.map((data, index) => {
+            const columns = data.columns?.map((column) => getColumn(table, column));
+            let constraint = unique(isDefined(data.name) ? toSnakeCase(data.name) : undefined).on(...columns);
+            if (data.options?.nulls == 'not distinct') {
+                constraint = constraint.nullsNotDistinct();
+            }
+            return [`unique_${index}`, constraint];
+        });
+        return {
+            ...isDefined(uniqueEntries) ? fromEntries(uniqueEntries) : undefined
+        };
+    });
+    return drizzleSchema; // eslint-disable-line @typescript-eslint/no-unsafe-return
+}
+function getPostgresColumn(tableName, columnName, dbSchema, propertySchema, reflectionData) {
+    let nullable = false;
+    let array = false;
+    let baseSchema = propertySchema;
+    while (true) {
+        if ((baseSchema instanceof NullableSchema) || (baseSchema instanceof OptionalSchema)) {
+            nullable = true;
+            baseSchema = baseSchema.schema;
+        }
+        else if (baseSchema instanceof ArraySchema) {
+            array = true;
+            baseSchema = baseSchema.itemSchema;
+        }
+        else {
+            break;
+        }
+    }
+    let column = getPostgresBaseColumn(tableName, columnName, dbSchema, baseSchema);
+    if (array) {
+        column = column.array();
+    }
+    if (!nullable) {
+        column = column.notNull();
+    }
+    if (isDefined(reflectionData.unique)) {
+        column = column.unique(reflectionData.unique.name, isString(reflectionData.unique.options?.nulls) ? { nulls: reflectionData.unique.options.nulls } : undefined);
+    }
+    if (reflectionData.primaryKey == true) {
+        column = column.primaryKey();
+    }
+    return column;
+}
+function getPostgresBaseColumn(tableName, columnName, dbSchema, schema) {
+    if (schema instanceof NumberSchema) {
+        return schema.integer
+            ? integer(columnName)
+            : doublePrecision(columnName);
+    }
+    if (schema instanceof UuidSchema) {
+        let column = uuid(columnName);
+        if (schema.defaultRandom) {
+            column = column.defaultRandom();
+        }
+        return column;
+    }
+    if (schema instanceof StringSchema) {
+        return text(columnName);
+    }
+    if (schema instanceof BooleanSchema) {
+        return boolean(columnName);
+    }
+    if (schema instanceof EnumerationSchema) {
+        const pgEnum = getPgEnum(tableName, columnName, dbSchema, schema.enumeration);
+        return pgEnum(columnName);
+    }
+    throw new NotSupportedError(`Schema ${schema.constructor.name} not supported`);
+}
+const enums = new Map();
+export function registerEnum(enumeration, name) {
+    enums.set(enumeration, name);
+}
+function getPgEnum(tableName, columnName, dbSchema, enumeration) {
+    const values = (isArray(enumeration) ? enumeration : enumValues(enumeration))
+        .map((value) => value.toString());
+    const enumName = enums.get(enumeration) ?? `${tableName}_${columnName}_enum`;
+    return dbSchema.enum(enumName, values);
+}
+function getDefaultTableName(type) {
+    return toSnakeCase(isString(type.entityName) ? type.entityName : type.name);
+}

package/orm/entity.d.ts

@@ -1,4 +1,8 @@
-import type { Record, TypedOmit } from '../types.js';
+import type { Record, Type, TypedOmit } from '../types.js';
+import { type HasDefault, type IsPrimaryKey, Uuid } from './types.js';
+export interface EntityType<T extends Entity = Entity> extends Type<T> {
+    readonly entityName: string;
+}
 export declare abstract class EntityMetadata {
     revision: number;
     revisionTimestamp: number;
@@ -7,7 +11,7 @@ export declare abstract class EntityMetadata {
     attributes: Record;
 }
 export declare abstract class Entity {
-    id: string;
+    id: IsPrimaryKey<HasDefault<Uuid>>;
     metadata: EntityMetadata;
 }
 export type NewEntity<T extends Entity> = TypedOmit<T, 'id' | 'metadata'> & {

package/orm/entity.js

@@ -8,6 +8,8 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 import { NumberProperty, Property, any, record } from '../schema/index.js';
+import { PrimaryKey } from './decorators.js';
+import { Uuid } from './types.js';
 export class EntityMetadata {
     revision;
     revisionTimestamp;
@@ -16,15 +18,15 @@ export class EntityMetadata {
     attributes;
 }
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revision", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "revisionTimestamp", void 0);
 __decorate([
-    Property(),
+    NumberProperty(),
     __metadata("design:type", Number)
 ], EntityMetadata.prototype, "createTimestamp", void 0);
 __decorate([
@@ -37,13 +39,11 @@ __decorate([
 ], EntityMetadata.prototype, "attributes", void 0);
 export class Entity {
     id;
+    // @Property(EntityMetadata)
     metadata;
 }
 __decorate([
-    Property(),
-    __metadata("design:type", String)
+    PrimaryKey(),
+    Uuid({ defaultRandom: true }),
+    __metadata("design:type", Object)
 ], Entity.prototype, "id", void 0);
-__decorate([
-    Property(EntityMetadata),
-    __metadata("design:type", EntityMetadata)
-], Entity.prototype, "metadata", void 0);

package/orm/index.d.ts

@@ -1,7 +1,6 @@
 export * from './decorators.js';
+export * from './drizzle/schema-converter.js';
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.js';
-export * from './schema-converter.js';
-export * from './schema.js';
 export * from './types.js';

package/orm/index.js

@@ -1,7 +1,6 @@
 export * from './decorators.js';
+export * from './drizzle/schema-converter.js';
 export * from './entity.js';
 export * from './query.js';
 export * from './repository.js';
-export * from './schema-converter.js';
-export * from './schema.js';
 export * from './types.js';

package/orm/repository.d.ts

@@ -1,5 +1,6 @@
-import type { Paths, Type, TypedOmit } from '../types.js';
-import type { Entity, EntityMetadata, NewEntity } from './entity.js';
+import type { Paths, TypedOmit } from '../types.js';
+import { SQL } from 'drizzle-orm';
+import type { Entity, EntityMetadata, EntityType, NewEntity } from './entity.js';
 import type { Query } from './query.js';
 export declare const repositoryType: unique symbol;
 export type OrderOptions<T extends Entity> = {
@@ -17,34 +18,36 @@ export type EntityMetadataUpdate = {
     metadata?: Partial<EntityMetadata>;
 };
 export type EntityUpdate<T extends Entity> = Partial<TypedOmit<T, 'metadata'>> & EntityMetadataUpdate;
+export declare const entityType: import("../injector/token.js").InjectionToken<EntityType<any>, never>;
 export declare abstract class EntityRepository<T extends Entity = Entity> {
-    readonly type: Type<T>;
+    readonly type: EntityType<T>;
+    readonly schema: import("./drizzle/schema-converter.js").PgTableFromType<"", EntityType<Entity>, string>;
     readonly database: import("drizzle-orm/node-postgres").NodePgDatabase<Record<string, never>> & {
-        $client: null;
+        $client: import("drizzle-orm/node-postgres").NodePgClient;
     };
-    load(_id: string): Promise<T>;
-    abstract tryLoad(id: string): Promise<T | undefined>;
-    abstract loadByFilter(query: Query<T>, options?: LoadOptions<T>): Promise<T>;
-    abstract tryLoadByFilter(query: Query<T>, options?: LoadOptions<T>): Promise<T | undefined>;
-    abstract loadMany(ids: string[], options?: LoadManyOptions<T>): Promise<T[]>;
-    abstract loadManyCursor(ids: string[], options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    abstract loadManyByFilter(query: Query<T>, options?: LoadManyOptions<T>): Promise<T[]>;
-    abstract loadManyByFilterCursor(query: Query<T>, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    abstract loadAll(options?: LoadManyOptions<T>): Promise<T[]>;
-    abstract loadAllCursor(options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
-    abstract count(): Promise<number>;
-    abstract countByFilter(query: Query<T>): Promise<number>;
-    abstract has(id: string): Promise<boolean>;
-    abstract hasByFilter(query: Query<T>): Promise<boolean>;
-    abstract hasAll(ids: string[]): Promise<boolean>;
-    abstract insert(entity: NewEntity<T>): Promise<T>;
+    load(id: string): Promise<T>;
+    tryLoad(id: string): Promise<T | undefined>;
+    loadByQuery(query: Query<T> | SQL | undefined, options?: LoadOptions<T>): Promise<T>;
+    tryLoadByQuery(query: Query<T> | SQL | undefined, options?: LoadOptions<T>): Promise<T | undefined>;
+    loadMany(ids: string[], options?: LoadManyOptions<T>): Promise<T[]>;
+    loadManyCursor(ids: string[], options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    loadManyByQuery(query: Query<T> | SQL | undefined, options?: LoadManyOptions<T>): Promise<T[]>;
+    loadManyByQueryCursor(query: Query<T> | SQL | undefined, options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    loadAll(options?: LoadManyOptions<T>): Promise<T[]>;
+    loadAllCursor(options?: LoadManyOptions<T>): AsyncIterableIterator<T>;
+    count(): Promise<number>;
+    countByQuery(query: Query<T> | SQL): Promise<number>;
+    has(id: string): Promise<boolean>;
+    hasByQuery(query: Query<T> | SQL): Promise<boolean>;
+    hasAll(ids: string[]): Promise<boolean>;
+    insert(_entity: NewEntity<T>): Promise<T>;
     abstract insertMany(entities: NewEntity<T>[]): Promise<T[]>;
     abstract update(id: string, update: EntityUpdate<T>): Promise<void>;
-    abstract updateByFilter(query: Query<T>, update: EntityUpdate<T>): Promise<void>;
+    abstract updateByQuery(query: Query<T>, update: EntityUpdate<T>): Promise<void>;
     abstract updateMany(ids: string[], update: EntityUpdate<T>): Promise<void>;
-    abstract updateManyByFilter(filter: Query<T>, update: EntityUpdate<T>): Promise<void>;
+    abstract updateManyByQuery(filter: Query<T>, update: EntityUpdate<T>): Promise<void>;
     abstract delete(id: string): Promise<boolean>;
     abstract deleteMany(ids: string[]): Promise<number>;
-    abstract deleteByFilter(query: Query<T>): Promise<boolean>;
-    abstract deleteManyByFilter(query: Query<T>): Promise<number>;
+    abstract deleteByQuery(query: Query<T>): Promise<boolean>;
+    abstract deleteManyByQuery(query: Query<T>): Promise<number>;
 }

package/orm/repository.js

@@ -1,11 +1,128 @@
-import { NotImplementedError } from '../errors/not-implemented.error.js';
+/* eslint-disable @typescript-eslint/no-non-null-asserted-optional-chain */
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    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';
+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';
 export const repositoryType = Symbol('repositoryType');
-export class EntityRepository {
-    type;
-    database = drizzle(null);
-    async load(_id) {
-        // const result = await this.database.select({ name2: mySchemaUsers.name }).from(mySchemaUsers).leftJoin();
+export const entityType = injectionToken('Entity type');
+let EntityRepository = class EntityRepository {
+    type = inject(entityType);
+    schema = getDrizzleTableFromType('', this.type);
+    database = drizzle('');
+    async load(id) {
+        const entity = await this.tryLoad(id);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} ${id} not found.`);
+        }
+        return entity;
+    }
+    async tryLoad(id) {
+        return this.tryLoadByQuery(eq(this.schema.id, id));
+    }
+    async loadByQuery(query, options) {
+        const entity = await this.tryLoadByQuery(query, options);
+        if (isUndefined(entity)) {
+            throw new NotFoundError(`${this.type.entityName} not found.`);
+        }
+        return entity;
+    }
+    async tryLoadByQuery(query, options) {
+        if (!(query instanceof SQL)) {
+            throw new NotSupportedError();
+        }
+        const dbQuery = this.database.select()
+            .from(this.schema)
+            .where(query)
+            .offset(options?.offset);
+        const [entity] = (await dbQuery);
+        return entity;
+    }
+    async loadMany(ids, options) {
+        return this.loadManyByQuery(inArray(this.schema.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)
+            .offset(options?.offset)
+            .limit(options?.limit);
+        return dbQuery;
+    }
+    async *loadManyByQueryCursor(query, options) {
+        const entities = await this.loadManyByQuery(query, options);
+        yield* entities;
+    }
+    async loadAll(options) {
+        return this.loadManyByQuery(undefined, options);
+    }
+    async *loadAllCursor(options) {
+        const entities = await this.loadAll(options);
+        yield* entities;
+    }
+    async count() {
+        const dbQuery = this.database
+            .select({ count: count() })
+            .from(this.schema);
+        const [result] = await dbQuery;
+        return assertDefinedPass(result).count;
+    }
+    async countByQuery(query) {
+        if (!(query instanceof SQL)) {
+            throw new NotSupportedError();
+        }
+        const dbQuery = this.database
+            .select({ count: count() })
+            .from(this.schema)
+            .where(query);
+        const [result] = await dbQuery;
+        return assertDefinedPass(result).count;
+    }
+    async has(id) {
+        return this.hasByQuery(eq(this.schema.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 [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;
+    }
+    async insert(_entity) {
+        // await this.database.insert(this.schema).values([entity as T]);
         throw new NotImplementedError();
     }
-}
+};
+EntityRepository = __decorate([
+    Singleton()
+], EntityRepository);
+export { EntityRepository };

package/orm/schemas/index.d.ts

@@ -0,0 +1 @@
+export * from './uuid.js';

package/orm/schemas/index.js

@@ -0,0 +1 @@
+export * from './uuid.js';

package/orm/schemas/uuid.d.ts

@@ -0,0 +1,11 @@
+import { StringSchema, type SchemaPropertyDecorator, type SchemaPropertyDecoratorOptions } from '../../schema/index.js';
+export type UuidSchemaOptions = {
+    defaultRandom?: boolean;
+};
+export declare class UuidSchema extends StringSchema {
+    readonly name = "uuid";
+    readonly defaultRandom: boolean;
+    constructor(options?: UuidSchemaOptions);
+}
+export declare function uuid(options?: UuidSchemaOptions): UuidSchema;
+export declare function Uuid(options?: UuidSchemaOptions & SchemaPropertyDecoratorOptions): SchemaPropertyDecorator;

package/orm/schemas/uuid.js

@@ -0,0 +1,16 @@
+import { Property, StringSchema } from '../../schema/index.js';
+const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/u;
+export class UuidSchema extends StringSchema {
+    name = 'uuid';
+    defaultRandom;
+    constructor(options) {
+        super({ pattern: uuidPattern });
+        this.defaultRandom = options?.defaultRandom ?? false;
+    }
+}
+export function uuid(options) {
+    return new UuidSchema(options);
+}
+export function Uuid(options) {
+    return Property(uuid(options), options);
+}

package/orm/types.d.ts

@@ -1,8 +1,21 @@
+import type { HasDefault as DrizzleHasDefault, IsPrimaryKey as DrizzleIsPrimaryKey } from 'drizzle-orm';
+import type { boolean, doublePrecision, integer, PgColumnBuilderBase, text, uuid } from 'drizzle-orm/pg-core';
+import type { GetTagMetadata, Tagged, UnwrapTagged } from 'type-fest';
 import { Integer } from '../schema/index.js';
-import type { doublePrecision, integer, uuid } from 'drizzle-orm/pg-core';
-import type { Tagged } from 'type-fest';
-export declare function Uuid(): PropertyDecorator & MethodDecorator;
-export type Uuid<ColumnName extends string> = Tagged<string, 'column', ReturnType<typeof uuid<ColumnName>>>;
-export type Integer<ColumnName extends string> = Tagged<number, 'column', ReturnType<typeof integer<ColumnName>>>;
-export type DoublePrecision<ColumnName extends string> = Tagged<number, 'column', ReturnType<typeof doublePrecision<ColumnName>>>;
-export { Integer };
+import type { Record } from '../types.js';
+import { Uuid } from './schemas/index.js';
+export type IsPrimaryKey<T> = T extends Tagged<unknown, 'column', PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, 'column', DrizzleIsPrimaryKey<GetTagMetadata<T, 'column'>>> : Tagged<T, 'column', ColumnBuilder<T>>;
+export type HasDefault<T> = T extends Tagged<unknown, 'column', PgColumnBuilderBase> ? Tagged<UnwrapTagged<T>, 'column', DrizzleHasDefault<GetTagMetadata<T, 'column'>>> : Tagged<T, 'column', ColumnBuilder<T>>;
+export type Nested<T extends Record> = Tagged<T, 'column', {
+    nested: T;
+}>;
+export type ColumnBuilder<T, ColumnName extends string = never> = T extends Tagged<T, 'column', any> ? GetTagMetadata<T, 'column'> : T extends string ? string extends ColumnName ? ReturnType<typeof text<ColumnName, string, [string, ...string[]]>> : ReturnType<typeof text<string, [string, ...string[]]>> : T extends number ? string extends ColumnName ? ReturnType<typeof doublePrecision<ColumnName>> : ReturnType<typeof doublePrecision> : T extends boolean ? string extends ColumnName ? ReturnType<typeof boolean<ColumnName>> : ReturnType<typeof boolean> : never;
+export type TypeBuilder<T, ColumnName extends string = never> = [
+    ColumnName
+] extends [never] ? T extends Tagged<any, 'column', PgColumnBuilderBase> ? T : T extends infer U ? Tagged<U, 'column', ColumnBuilder<U>> : never : never;
+export type Text = Tagged<string, 'column', ReturnType<typeof text<string, [string, ...string[]]>>>;
+export type Uuid = Tagged<string, 'column', ReturnType<typeof uuid>>;
+export type Integer = Tagged<number, 'column', ReturnType<typeof integer>>;
+export type DoublePrecision = Tagged<number, 'column', ReturnType<typeof doublePrecision>>;
+export type Boolean = Tagged<number, 'column', ReturnType<typeof boolean>>;
+export { Integer, Uuid };

package/orm/types.js

@@ -1,6 +1,4 @@
 /* eslint-disable @typescript-eslint/no-redeclare, @typescript-eslint/naming-convention */
-import { createSchemaPropertyDecorator, Integer, string } from '../schema/index.js';
-export function Uuid() {
-    return createSchemaPropertyDecorator({ schema: string() });
-}
-export { Integer };
+import { Integer } from '../schema/index.js';
+import { Uuid } from './schemas/index.js';
+export { Integer, Uuid };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tstdl/base",
-  "version": "0.91.28",
+  "version": "0.91.31",
   "author": "Patrick Hein",
   "publishConfig": {
     "access": "public"
@@ -56,6 +56,7 @@
     "./json-path": "./json-path/index.js",
     "./jsx": "./jsx/index.js",
     "./key-value-store": "./key-value-store/index.js",
+    "./key-value-store/mongo": "./key-value-store/mongo/index.js",
     "./lock": "./lock/index.js",
     "./lock/mongo": "./lock/mongo/index.js",
     "./lock/web": "./lock/web/index.js",
@@ -125,8 +126,10 @@
     "@types/mjml": "4.7",
     "@types/node": "22",
     "@types/nodemailer": "6.4",
+    "@types/pg": "8.11",
     "@typescript-eslint/eslint-plugin": "7.17",
     "concurrently": "9.0",
+    "drizzle-kit": "0.26",
     "eslint": "8.57",
     "eslint-import-resolver-typescript": "3.6",
     "eslint-plugin-import": "2.31",
@@ -144,14 +147,14 @@
     "@zxcvbn-ts/language-de": "^3.0",
     "@zxcvbn-ts/language-en": "^3.0",
     "chroma-js": "^2.6",
-    "drizzle-orm": "^0.34",
+    "drizzle-orm": "^0.35",
     "handlebars": "^4.7",
     "koa": "^2.15",
     "minio": "^8.0",
     "mjml": "^4.15",
-    "mongodb": "^6.9",
+    "mongodb": "^6.10",
     "nodemailer": "^6.9",
-    "pg": "^8.13",
+    "pg": "8.13",
     "playwright": "^1.48",
     "preact": "^10.24",
     "preact-render-to-string": "^6.5",

package/reflection/registry.d.ts

@@ -1,5 +1,5 @@
 import type { AbstractConstructor } from '../types.js';
-import { ReflectionDataMap } from './reflection-data-map.js';
+import { ContextDataMap } from '../data-structures/context-data-map.js';
 import type { DecoratorData } from './types.js';
 export type ReflectionMetadata = TypeMetadata | PropertyMetadata | MethodMetadata | ConstructorParameterMetadata | MethodParameterMetadata;
 export type MetadataType = 'type' | 'property' | 'method' | 'method-parameter' | 'constructor-parameter';
@@ -15,31 +15,34 @@ export type TypeMetadata = MetadataBase<'type'> & {
     readonly staticProperties: ReadonlyMap<string | symbol, PropertyMetadata>;
     readonly methods: ReadonlyMap<string | symbol, MethodMetadata>;
     readonly staticMethods: ReadonlyMap<string | symbol, MethodMetadata>;
-    readonly data: ReflectionDataMap;
+    readonly data: ContextDataMap;
 };
 export type PropertyMetadata = MetadataBase<'property'> & {
     key: string | symbol;
     type: AbstractConstructor;
     isAccessor: boolean;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
+    inherited: boolean;
 };
 export type MethodMetadata = MetadataBase<'method'> & {
     parameters: MethodParameterMetadata[];
     returnType: AbstractConstructor | undefined;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
+    inherited: boolean;
 };
 export type ConstructorParameterMetadata = MetadataBase<'constructor-parameter'> & {
     type: AbstractConstructor | undefined;
     index: number;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
 };
 export type MethodParameterMetadata = MetadataBase<'method-parameter'> & {
     type: AbstractConstructor;
     index: number;
-    data: ReflectionDataMap;
+    data: ContextDataMap;
 };
 export type ParameterMetadata = ConstructorParameterMetadata | MethodParameterMetadata;
 export declare class ReflectionRegistry {
+    #private;
     private readonly metadataMap;
     private readonly finalizedTypesSet;
     constructor();