@uql/core 1.0.11 → 3.0.0

package/dist/test/spec.util.d.ts

@@ -0,0 +1,14 @@
+/// <reference types="bun-types" resolution-mode="require"/>
+import { afterAll, afterEach, beforeAll, beforeEach } from 'bun:test';
+export declare function createSpec<T extends Spec>(spec: T): void;
+declare const hooks: {
+    readonly beforeAll: typeof beforeAll;
+    readonly beforeEach: typeof beforeEach;
+    readonly afterEach: typeof afterEach;
+    readonly afterAll: typeof afterAll;
+};
+type SpecHooks = Partial<typeof hooks>;
+export type Spec = SpecHooks & {
+    readonly [k: string]: (() => void | Promise<void>) | any;
+};
+export {};

package/dist/test/spec.util.js

@@ -0,0 +1,50 @@
+import { afterAll, afterEach, beforeAll, beforeEach, describe, it } from 'bun:test';
+export function createSpec(spec) {
+    const proto = Object.getPrototypeOf(spec);
+    let describeFn;
+    const specName = proto.constructor.name;
+    if (specName.startsWith('fff')) {
+        describeFn = describe.only;
+    }
+    else if (specName.startsWith('xxx')) {
+        describeFn = describe.skip;
+    }
+    else {
+        describeFn = describe;
+    }
+    describeFn(specName, () => createTestCases(spec));
+}
+function createTestCases(spec) {
+    let proto = Object.getPrototypeOf(spec);
+    const processedMethodsMap = {};
+    while (proto.constructor !== Object) {
+        for (const key of Object.getOwnPropertyNames(proto)) {
+            const isProcessed = processedMethodsMap[key];
+            processedMethodsMap[key] = true;
+            if (isProcessed || key === 'constructor' || typeof spec[key] !== 'function') {
+                continue;
+            }
+            const callback = spec[key].bind(spec);
+            if (hooks[key]) {
+                hooks[key](callback);
+            }
+            else if (key.startsWith('should')) {
+                it(key, callback);
+            }
+            else if (key.startsWith('fffShould')) {
+                it.only(key, callback);
+            }
+            else if (key.startsWith('xxxShould')) {
+                it.skip(key, callback);
+            }
+        }
+        proto = Object.getPrototypeOf(proto);
+    }
+}
+const hooks = {
+    beforeAll,
+    beforeEach,
+    afterEach,
+    afterAll,
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/type/entity.d.ts

@@ -0,0 +1,169 @@
+import type { QueryRaw } from './query.js';
+import type { Scalar, Type } from './utility.js';
+/**
+ * Allow to customize the name of the property that identifies an entity
+ */
+export declare const idKey: unique symbol;
+/**
+ * Infers the key names of an entity
+ */
+export type Key<E> = keyof E & string;
+/**
+ * Infers the field names of an entity
+ */
+export type FieldKey<E> = {
+    readonly [K in keyof E]: E[K] extends Scalar ? K : never;
+}[Key<E>];
+/**
+ * Infers the relation names of an entity
+ */
+export type RelationKey<E> = {
+    readonly [K in keyof E]: E[K] extends Scalar ? never : K;
+}[Key<E>];
+/**
+ * Infers the field values of an entity
+ */
+export type FieldValue<E> = E[FieldKey<E>];
+/**
+ * Infers the name of the key identifier on an entity
+ */
+export type IdKey<E> = E extends {
+    [idKey]?: infer K;
+} ? K & FieldKey<E> : E extends {
+    _id?: unknown;
+} ? '_id' & FieldKey<E> : E extends {
+    id?: unknown;
+} ? 'id' & FieldKey<E> : E extends {
+    uuid?: unknown;
+} ? 'uuid' & FieldKey<E> : FieldKey<E>;
+/**
+ * Infers the value of the key identifier on an entity
+ */
+export type IdValue<E> = E[IdKey<E>];
+/**
+ * Infers the values of the relations on an entity
+ */
+export type RelationValue<E> = E[RelationKey<E>];
+/**
+ * Configurable options for an entity
+ */
+export type EntityOptions = {
+    readonly name?: string;
+    readonly softDelete?: boolean;
+};
+/**
+ * SQL column types supported by uql migrations
+ */
+export type ColumnType = 'int' | 'smallint' | 'bigint' | 'float' | 'double' | 'decimal' | 'numeric' | 'real' | 'boolean' | 'char' | 'varchar' | 'text' | 'uuid' | 'date' | 'time' | 'timestamp' | 'timestamptz' | 'json' | 'jsonb' | 'blob' | 'bytea' | 'vector' | 'serial' | 'bigserial';
+/**
+ * Configurable options for a field
+ */
+export type FieldOptions = {
+    readonly name?: string;
+    readonly isId?: true;
+    readonly type?: any;
+    readonly reference?: EntityGetter;
+    readonly virtual?: QueryRaw;
+    readonly updatable?: boolean;
+    readonly eager?: boolean;
+    readonly onInsert?: OnFieldCallback;
+    readonly onUpdate?: OnFieldCallback;
+    readonly onDelete?: OnFieldCallback;
+    /**
+     * SQL column type for migrations. If not specified, inferred from TypeScript type.
+     */
+    readonly columnType?: ColumnType;
+    /**
+     * Column length (e.g., VARCHAR(100)). Defaults to 255 for varchar.
+     */
+    readonly length?: number;
+    /**
+     * Precision for decimal/numeric types.
+     */
+    readonly precision?: number;
+    /**
+     * Scale for decimal/numeric types.
+     */
+    readonly scale?: number;
+    /**
+     * Whether the column allows NULL values. Defaults to true except for ID fields.
+     */
+    readonly nullable?: boolean;
+    /**
+     * Whether the column has a UNIQUE constraint.
+     */
+    readonly unique?: boolean;
+    /**
+     * Default value for the column.
+     */
+    readonly defaultValue?: Scalar | null;
+    /**
+     * Whether the column is auto-incrementing (for integer IDs).
+     */
+    readonly autoIncrement?: boolean;
+    /**
+     * Index configuration. true for simple index, string for named index.
+     */
+    readonly index?: boolean | string;
+    /**
+     * Column comment/description for database documentation.
+     */
+    readonly comment?: string;
+};
+export type OnFieldCallback = Scalar | QueryRaw | (() => Scalar | QueryRaw);
+export type EntityGetter<E = any> = () => Type<E>;
+export type CascadeType = 'persist' | 'delete';
+export type RelationOptions<E = any> = {
+    entity?: EntityGetter<E>;
+    cardinality: RelationCardinality;
+    readonly cascade?: boolean | CascadeType;
+    mappedBy?: RelationMappedBy<E>;
+    through?: EntityGetter<RelationValue<E>>;
+    references?: RelationReferences;
+};
+type RelationOptionsOwner<E> = Pick<RelationOptions<E>, 'entity' | 'references' | 'cascade'>;
+type RelationOptionsInverseSide<E> = Required<Pick<RelationOptions<E>, 'entity' | 'mappedBy'>> & Pick<RelationOptions<E>, 'cascade'>;
+type RelationOptionsThroughOwner<E> = Required<Pick<RelationOptions<E>, 'entity'>> & Pick<RelationOptions<E>, 'through' | 'references' | 'cascade'>;
+export type RelationKeyMap<E> = {
+    readonly [K in keyof E]: K;
+};
+export type RelationKeyMapper<E> = (keyMap: RelationKeyMap<E>) => Key<E>;
+export type RelationReferences = {
+    readonly local: string;
+    readonly foreign: string;
+}[];
+export type RelationMappedBy<E> = Key<E> | RelationKeyMapper<E>;
+export type RelationCardinality = '11' | 'm1' | '1m' | 'mm';
+export type RelationOneToOneOptions<E> = RelationOptionsOwner<E> | RelationOptionsInverseSide<E>;
+export type RelationOneToManyOptions<E> = RelationOptionsInverseSide<E> | RelationOptionsThroughOwner<E>;
+export type RelationManyToOneOptions<E> = RelationOptionsOwner<E>;
+export type RelationManyToManyOptions<E> = RelationOptionsThroughOwner<E> | RelationOptionsInverseSide<E>;
+/**
+ * Wrapper type for relation type definitions in entities.
+ * Used to circumvent ESM modules circular dependency issue caused by reflection metadata saving the type of the property.
+ *
+ * Usage example:
+ * @Entity()
+ * export default class User {
+ *
+ *     @OneToOne(() => Profile, profile => profile.user)
+ *     profile: Relation<Profile>;
+ *
+ * }
+ */
+export type Relation<T> = T;
+export type EntityMeta<E> = {
+    readonly entity: Type<E>;
+    name?: string;
+    id?: IdKey<E>;
+    softDelete?: FieldKey<E>;
+    fields: {
+        [K in FieldKey<E>]?: FieldOptions;
+    };
+    relations: {
+        [K in RelationKey<E>]?: RelationOptions;
+    };
+    processed?: boolean;
+};
+export type Primitive = string | number | symbol;
+export {};

package/dist/type/entity.js

@@ -0,0 +1,5 @@
+/**
+ * Allow to customize the name of the property that identifies an entity
+ */
+export const idKey = Symbol('idKey');
+//# sourceMappingURL=data:application/json;base64,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

package/dist/type/index.d.ts

@@ -0,0 +1,9 @@
+export * from './entity.js';
+export * from './migration.js';
+export * from './namingStrategy.js';
+export * from './querier.js';
+export * from './querierPool.js';
+export * from './query.js';
+export * from './repository.js';
+export * from './universalQuerier.js';
+export * from './utility.js';

package/dist/type/index.js

@@ -0,0 +1,10 @@
+export * from './entity.js';
+export * from './migration.js';
+export * from './namingStrategy.js';
+export * from './querier.js';
+export * from './querierPool.js';
+export * from './query.js';
+export * from './repository.js';
+export * from './universalQuerier.js';
+export * from './utility.js';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZS9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxjQUFjLGFBQWEsQ0FBQztBQUM1QixjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMscUJBQXFCLENBQUM7QUFDcEMsY0FBYyxjQUFjLENBQUM7QUFDN0IsY0FBYyxrQkFBa0IsQ0FBQztBQUNqQyxjQUFjLFlBQVksQ0FBQztBQUMzQixjQUFjLGlCQUFpQixDQUFDO0FBQ2hDLGNBQWMsdUJBQXVCLENBQUM7QUFDdEMsY0FBYyxjQUFjLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgKiBmcm9tICcuL2VudGl0eS5qcyc7XG5leHBvcnQgKiBmcm9tICcuL21pZ3JhdGlvbi5qcyc7XG5leHBvcnQgKiBmcm9tICcuL25hbWluZ1N0cmF0ZWd5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcmllci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3F1ZXJpZXJQb29sLmpzJztcbmV4cG9ydCAqIGZyb20gJy4vcXVlcnkuanMnO1xuZXhwb3J0ICogZnJvbSAnLi9yZXBvc2l0b3J5LmpzJztcbmV4cG9ydCAqIGZyb20gJy4vdW5pdmVyc2FsUXVlcmllci5qcyc7XG5leHBvcnQgKiBmcm9tICcuL3V0aWxpdHkuanMnO1xuIl19

package/dist/type/migration.d.ts

@@ -0,0 +1,213 @@
+import type { Dialect, EntityMeta, FieldOptions, NamingStrategy, SqlQuerier, Type } from './index.js';
+/**
+ * Defines a migration using a simple object literal
+ */
+export interface MigrationDefinition {
+    readonly name?: string;
+    readonly up: (querier: SqlQuerier) => Promise<void>;
+    readonly down: (querier: SqlQuerier) => Promise<void>;
+}
+/**
+ * Represents a single database migration
+ */
+export interface Migration extends MigrationDefinition {
+    /**
+     * Unique name/identifier for this migration (typically timestamp + description)
+     */
+    readonly name: string;
+}
+/**
+ * Storage backend for tracking which migrations have been executed
+ */
+export interface MigrationStorage {
+    /**
+     * Get list of already executed migration names
+     */
+    executed(): Promise<string[]>;
+    /**
+     * Mark a migration as executed (called within migration transaction)
+     */
+    logWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;
+    /**
+     * Remove a migration from the executed list (called within migration transaction)
+     */
+    unlogWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;
+    /**
+     * Ensure the storage is initialized (e.g., create migrations table)
+     */
+    ensureStorage(): Promise<void>;
+}
+/**
+ * Configuration options for the Migrator
+ */
+export interface MigratorOptions {
+    /**
+     * The database dialect. Defaults to 'postgres'.
+     */
+    readonly dialect?: Dialect;
+    /**
+     * Directory containing migration files. Defaults to './migrations'.
+     */
+    readonly migrationsPath?: string;
+    /**
+     * Custom storage implementation. Defaults to DatabaseMigrationStorage.
+     */
+    readonly storage?: MigrationStorage;
+    /**
+     * Table name for storing migration state. Defaults to 'uql_migrations'.
+     */
+    readonly tableName?: string;
+    /**
+     * Logger function for migration output
+     */
+    readonly logger?: (message: string) => void;
+    /**
+     * Entities to use for schema generation
+     */
+    readonly entities?: Type<unknown>[];
+    /**
+     * Naming strategy for database tables and columns
+     */
+    readonly namingStrategy?: NamingStrategy;
+    /**
+     * Custom schema generator for DDL operations.
+     * If not provided, it will be inferred from the dialect.
+     */
+    readonly schemaGenerator?: SchemaGenerator;
+}
+/**
+ * Result of a migration run
+ */
+export interface MigrationResult {
+    readonly name: string;
+    readonly direction: 'up' | 'down';
+    readonly duration: number;
+    readonly success: boolean;
+    readonly error?: Error;
+}
+/**
+ * Represents a column in a database table schema
+ */
+export interface ColumnSchema {
+    readonly name: string;
+    readonly type: string;
+    readonly nullable: boolean;
+    readonly defaultValue?: unknown;
+    readonly isPrimaryKey: boolean;
+    readonly isAutoIncrement: boolean;
+    readonly isUnique: boolean;
+    readonly length?: number;
+    readonly precision?: number;
+    readonly scale?: number;
+    readonly comment?: string;
+}
+/**
+ * Represents a database table schema
+ */
+export interface TableSchema {
+    readonly name: string;
+    readonly columns: ColumnSchema[];
+    readonly primaryKey?: string[];
+    readonly indexes?: IndexSchema[];
+    readonly foreignKeys?: ForeignKeySchema[];
+}
+/**
+ * Represents an index in a database table
+ */
+export interface IndexSchema {
+    readonly name: string;
+    readonly columns: string[];
+    readonly unique: boolean;
+}
+/**
+ * Represents a foreign key constraint
+ */
+export interface ForeignKeySchema {
+    readonly name: string;
+    readonly columns: string[];
+    readonly referencedTable: string;
+    readonly referencedColumns: string[];
+    readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+    readonly onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';
+}
+/**
+ * Represents a difference between current and desired schema
+ */
+export interface SchemaDiff {
+    readonly tableName: string;
+    readonly type: 'create' | 'alter' | 'drop';
+    readonly columnsToAdd?: ColumnSchema[];
+    readonly columnsToAlter?: {
+        from: ColumnSchema;
+        to: ColumnSchema;
+    }[];
+    readonly columnsToDrop?: string[];
+    readonly indexesToAdd?: IndexSchema[];
+    readonly indexesToDrop?: string[];
+    readonly foreignKeysToAdd?: ForeignKeySchema[];
+    readonly foreignKeysToDrop?: string[];
+}
+/**
+ * Interface for generating DDL statements from entity metadata
+ */
+export interface SchemaGenerator {
+    /**
+     * Generate CREATE TABLE statement for an entity
+     */
+    generateCreateTable<E>(entity: Type<E>, options?: {
+        ifNotExists?: boolean;
+    }): string;
+    /**
+     * Generate DROP TABLE statement for an entity
+     */
+    generateDropTable<E>(entity: Type<E>): string;
+    /**
+     * Generate ALTER TABLE statements based on schema diff
+     */
+    generateAlterTable(diff: SchemaDiff): string[];
+    /**
+     * Generate rollback (down) statements for ALTER TABLE based on schema diff
+     */
+    generateAlterTableDown(diff: SchemaDiff): string[];
+    /**
+     * Generate CREATE INDEX statement
+     */
+    generateCreateIndex(tableName: string, index: IndexSchema): string;
+    /**
+     * Generate DROP INDEX statement
+     */
+    generateDropIndex(tableName: string, indexName: string): string;
+    /**
+     * Get the SQL type for a field based on its options
+     */
+    getSqlType(fieldOptions: FieldOptions, fieldType?: unknown): string;
+    /**
+     * Compare two schemas and return the differences
+     */
+    diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined;
+    /**
+     * Resolve table name using entity and naming strategy
+     */
+    resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string;
+    /**
+     * Resolve column name using field options and naming strategy
+     */
+    resolveColumnName(key: string, field: FieldOptions): string;
+}
+/**
+ * Interface for introspecting the current database schema
+ */
+export interface SchemaIntrospector {
+    /**
+     * Get the schema of a specific table
+     */
+    getTableSchema(tableName: string): Promise<TableSchema | undefined>;
+    /**
+     * Get all table names in the database
+     */
+    getTableNames(): Promise<string[]>;
+    /**
+     * Check if a table exists
+     */
+    tableExists(tableName: string): Promise<boolean>;
+}

package/dist/type/migration.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"migration.js","sourceRoot":"","sources":["../../src/type/migration.ts"],"names":[],"mappings":"","sourcesContent":["import type { Dialect, EntityMeta, FieldOptions, NamingStrategy, SqlQuerier, Type } from './index.js';\n\n/**\n * Defines a migration using a simple object literal\n */\nexport interface MigrationDefinition {\n  readonly name?: string;\n  readonly up: (querier: SqlQuerier) => Promise<void>;\n  readonly down: (querier: SqlQuerier) => Promise<void>;\n}\n\n/**\n * Represents a single database migration\n */\nexport interface Migration extends MigrationDefinition {\n  /**\n   * Unique name/identifier for this migration (typically timestamp + description)\n   */\n  readonly name: string;\n}\n\n/**\n * Storage backend for tracking which migrations have been executed\n */\nexport interface MigrationStorage {\n  /**\n   * Get list of already executed migration names\n   */\n  executed(): Promise<string[]>;\n\n  /**\n   * Mark a migration as executed (called within migration transaction)\n   */\n  logWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;\n\n  /**\n   * Remove a migration from the executed list (called within migration transaction)\n   */\n  unlogWithQuerier(querier: SqlQuerier, migrationName: string): Promise<void>;\n\n  /**\n   * Ensure the storage is initialized (e.g., create migrations table)\n   */\n  ensureStorage(): Promise<void>;\n}\n\n/**\n * Configuration options for the Migrator\n */\nexport interface MigratorOptions {\n  /**\n   * The database dialect. Defaults to 'postgres'.\n   */\n  readonly dialect?: Dialect;\n\n  /**\n   * Directory containing migration files. Defaults to './migrations'.\n   */\n  readonly migrationsPath?: string;\n\n  /**\n   * Custom storage implementation. Defaults to DatabaseMigrationStorage.\n   */\n  readonly storage?: MigrationStorage;\n\n  /**\n   * Table name for storing migration state. Defaults to 'uql_migrations'.\n   */\n  readonly tableName?: string;\n\n  /**\n   * Logger function for migration output\n   */\n  readonly logger?: (message: string) => void;\n\n  /**\n   * Entities to use for schema generation\n   */\n  readonly entities?: Type<unknown>[];\n\n  /**\n   * Naming strategy for database tables and columns\n   */\n  readonly namingStrategy?: NamingStrategy;\n\n  /**\n   * Custom schema generator for DDL operations.\n   * If not provided, it will be inferred from the dialect.\n   */\n  readonly schemaGenerator?: SchemaGenerator;\n}\n\n/**\n * Result of a migration run\n */\nexport interface MigrationResult {\n  readonly name: string;\n  readonly direction: 'up' | 'down';\n  readonly duration: number;\n  readonly success: boolean;\n  readonly error?: Error;\n}\n\n/**\n * Represents a column in a database table schema\n */\nexport interface ColumnSchema {\n  readonly name: string;\n  readonly type: string;\n  readonly nullable: boolean;\n  readonly defaultValue?: unknown;\n  readonly isPrimaryKey: boolean;\n  readonly isAutoIncrement: boolean;\n  readonly isUnique: boolean;\n  readonly length?: number;\n  readonly precision?: number;\n  readonly scale?: number;\n  readonly comment?: string;\n}\n\n/**\n * Represents a database table schema\n */\nexport interface TableSchema {\n  readonly name: string;\n  readonly columns: ColumnSchema[];\n  readonly primaryKey?: string[];\n  readonly indexes?: IndexSchema[];\n  readonly foreignKeys?: ForeignKeySchema[];\n}\n\n/**\n * Represents an index in a database table\n */\nexport interface IndexSchema {\n  readonly name: string;\n  readonly columns: string[];\n  readonly unique: boolean;\n}\n\n/**\n * Represents a foreign key constraint\n */\nexport interface ForeignKeySchema {\n  readonly name: string;\n  readonly columns: string[];\n  readonly referencedTable: string;\n  readonly referencedColumns: string[];\n  readonly onDelete?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';\n  readonly onUpdate?: 'CASCADE' | 'SET NULL' | 'RESTRICT' | 'NO ACTION';\n}\n\n/**\n * Represents a difference between current and desired schema\n */\nexport interface SchemaDiff {\n  readonly tableName: string;\n  readonly type: 'create' | 'alter' | 'drop';\n  readonly columnsToAdd?: ColumnSchema[];\n  readonly columnsToAlter?: { from: ColumnSchema; to: ColumnSchema }[];\n  readonly columnsToDrop?: string[];\n  readonly indexesToAdd?: IndexSchema[];\n  readonly indexesToDrop?: string[];\n  readonly foreignKeysToAdd?: ForeignKeySchema[];\n  readonly foreignKeysToDrop?: string[];\n}\n\n/**\n * Interface for generating DDL statements from entity metadata\n */\nexport interface SchemaGenerator {\n  /**\n   * Generate CREATE TABLE statement for an entity\n   */\n  generateCreateTable<E>(entity: Type<E>, options?: { ifNotExists?: boolean }): string;\n\n  /**\n   * Generate DROP TABLE statement for an entity\n   */\n  generateDropTable<E>(entity: Type<E>): string;\n\n  /**\n   * Generate ALTER TABLE statements based on schema diff\n   */\n  generateAlterTable(diff: SchemaDiff): string[];\n\n  /**\n   * Generate rollback (down) statements for ALTER TABLE based on schema diff\n   */\n  generateAlterTableDown(diff: SchemaDiff): string[];\n\n  /**\n   * Generate CREATE INDEX statement\n   */\n  generateCreateIndex(tableName: string, index: IndexSchema): string;\n\n  /**\n   * Generate DROP INDEX statement\n   */\n  generateDropIndex(tableName: string, indexName: string): string;\n\n  /**\n   * Get the SQL type for a field based on its options\n   */\n  getSqlType(fieldOptions: FieldOptions, fieldType?: unknown): string;\n\n  /**\n   * Compare two schemas and return the differences\n   */\n  diffSchema<E>(entity: Type<E>, currentSchema: TableSchema | undefined): SchemaDiff | undefined;\n\n  /**\n   * Resolve table name using entity and naming strategy\n   */\n  resolveTableName<E>(entity: Type<E>, meta: EntityMeta<E>): string;\n\n  /**\n   * Resolve column name using field options and naming strategy\n   */\n  resolveColumnName(key: string, field: FieldOptions): string;\n}\n\n/**\n * Interface for introspecting the current database schema\n */\nexport interface SchemaIntrospector {\n  /**\n   * Get the schema of a specific table\n   */\n  getTableSchema(tableName: string): Promise<TableSchema | undefined>;\n\n  /**\n   * Get all table names in the database\n   */\n  getTableNames(): Promise<string[]>;\n\n  /**\n   * Check if a table exists\n   */\n  tableExists(tableName: string): Promise<boolean>;\n}\n"]}

package/dist/type/namingStrategy.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Defines the naming strategy for database tables and columns.
+ */
+export interface NamingStrategy {
+    /**
+     * Translates entity name to table name.
+     */
+    tableName(entityName: string): string;
+    /**
+     * Translates property name to column name.
+     */
+    columnName(propertyName: string): string;
+    /**
+     * Translates entity names to join table name (many-to-many).
+     */
+    joinTableName(sourceEntityName: string, targetEntityName: string, propertyName?: string): string;
+}

package/dist/type/namingStrategy.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibmFtaW5nU3RyYXRlZ3kuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZS9uYW1pbmdTdHJhdGVneS50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBEZWZpbmVzIHRoZSBuYW1pbmcgc3RyYXRlZ3kgZm9yIGRhdGFiYXNlIHRhYmxlcyBhbmQgY29sdW1ucy5cbiAqL1xuZXhwb3J0IGludGVyZmFjZSBOYW1pbmdTdHJhdGVneSB7XG4gIC8qKlxuICAgKiBUcmFuc2xhdGVzIGVudGl0eSBuYW1lIHRvIHRhYmxlIG5hbWUuXG4gICAqL1xuICB0YWJsZU5hbWUoZW50aXR5TmFtZTogc3RyaW5nKTogc3RyaW5nO1xuICAvKipcbiAgICogVHJhbnNsYXRlcyBwcm9wZXJ0eSBuYW1lIHRvIGNvbHVtbiBuYW1lLlxuICAgKi9cbiAgY29sdW1uTmFtZShwcm9wZXJ0eU5hbWU6IHN0cmluZyk6IHN0cmluZztcbiAgLyoqXG4gICAqIFRyYW5zbGF0ZXMgZW50aXR5IG5hbWVzIHRvIGpvaW4gdGFibGUgbmFtZSAobWFueS10by1tYW55KS5cbiAgICovXG4gIGpvaW5UYWJsZU5hbWUoc291cmNlRW50aXR5TmFtZTogc3RyaW5nLCB0YXJnZXRFbnRpdHlOYW1lOiBzdHJpbmcsIHByb3BlcnR5TmFtZT86IHN0cmluZyk6IHN0cmluZztcbn1cbiJdfQ==

package/dist/type/querier.d.ts

@@ -0,0 +1,96 @@
+import type { Db } from 'mongodb';
+import type { IdValue } from './entity.js';
+import type { NamingStrategy } from './namingStrategy.js';
+import type { Query, QueryConflictPaths, QueryOne, QueryOptions, QuerySearch, QueryUpdateResult, SqlQueryDialect } from './query.js';
+import type { Repository } from './repository.js';
+import type { UniversalQuerier } from './universalQuerier.js';
+import type { Type } from './utility.js';
+/**
+ * Isolation levels for transactions.
+ */
+export type IsolationLevel = 'read uncommitted' | 'read committed' | 'repeteable read' | 'serializable';
+/**
+ * Supported SQL dialect identifiers.
+ */
+export type SqlDialect = 'postgres' | 'mysql' | 'mariadb' | 'sqlite';
+export type Dialect = SqlDialect | 'mongodb';
+export interface Querier extends UniversalQuerier {
+    findOneById<E>(entity: Type<E>, id: IdValue<E>, q?: QueryOne<E>): Promise<E>;
+    findOne<E>(entity: Type<E>, q: QueryOne<E>): Promise<E>;
+    findMany<E>(entity: Type<E>, q: Query<E>): Promise<E[]>;
+    findManyAndCount<E>(entity: Type<E>, q: Query<E>): Promise<[E[], number]>;
+    count<E>(entity: Type<E>, q: QuerySearch<E>): Promise<number>;
+    insertOne<E>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
+    insertMany<E>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
+    updateOneById<E>(entity: Type<E>, id: IdValue<E>, payload: E): Promise<number>;
+    updateMany<E>(entity: Type<E>, q: QuerySearch<E>, payload: E): Promise<number>;
+    upsertOne<E>(entity: Type<E>, conflictPaths: QueryConflictPaths<E>, payload: E): Promise<QueryUpdateResult>;
+    saveOne<E>(entity: Type<E>, payload: E): Promise<IdValue<E>>;
+    saveMany<E>(entity: Type<E>, payload: E[]): Promise<IdValue<E>[]>;
+    deleteOneById<E>(entity: Type<E>, id: IdValue<E>, opts?: QueryOptions): Promise<number>;
+    deleteMany<E>(entity: Type<E>, q: QuerySearch<E>, opts?: QueryOptions): Promise<number>;
+    getRepository<E>(entity: Type<E>): Repository<E>;
+    /**
+     * whether this querier is in a transaction or not.
+     */
+    readonly hasOpenTransaction: boolean;
+    /**
+     * run the given callback inside a transaction in this querier.
+     */
+    transaction<T>(callback: () => Promise<T>): Promise<T>;
+    /**
+     * starts a new transaction in this querier.
+     */
+    beginTransaction(): Promise<void>;
+    /**
+     * commits the currently active transaction in this querier.
+     */
+    commitTransaction(): Promise<void>;
+    /**
+     * aborts the currently active transaction in this querier.
+     */
+    rollbackTransaction(): Promise<void>;
+    /**
+     * release the querier to the pool.
+     */
+    release(): Promise<void>;
+}
+/**
+ * Extended querier interface for raw SQL execution.
+ * Implemented by AbstractSqlQuerier and all SQL-based queriers.
+ */
+export interface SqlQuerier extends Querier {
+    /**
+     * The SQL dialect (provides escapeIdChar and other dialect-specific info)
+     */
+    readonly dialect: SqlQueryDialect;
+    /**
+     * Execute a raw SQL query and return results
+     */
+    all<T>(query: string, values?: unknown[]): Promise<T[]>;
+    /**
+     * Execute a raw SQL command (INSERT, UPDATE, DELETE, DDL)
+     */
+    run(query: string, values?: unknown[]): Promise<QueryUpdateResult>;
+}
+/**
+ * Type guard to check if a querier supports raw SQL execution
+ */
+export declare function isSqlQuerier(querier: Querier): querier is SqlQuerier;
+/**
+ * Extended querier interface for MongoDB execution.
+ */
+export interface MongoQuerier extends Querier {
+    /**
+     * The MongoDB database instance.
+     */
+    readonly db: Db;
+}
+/**
+ * logger function to debug queries.
+ */
+export type Logger = (message: unknown, ...args: unknown[]) => unknown;
+export type ExtraOptions = {
+    readonly logger?: Logger;
+    readonly namingStrategy?: NamingStrategy;
+};

package/dist/type/querier.js

@@ -0,0 +1,11 @@
+/**
+ * Type guard to check if a querier supports raw SQL execution
+ */
+export function isSqlQuerier(querier) {
+    const q = querier;
+    return (typeof q.all === 'function' &&
+        typeof q.run === 'function' &&
+        q.dialect !== undefined &&
+        typeof q.dialect.escapeIdChar === 'string');
+}
+//# sourceMappingURL=data:application/json;base64,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