@uql/core 3.1.0 → 3.1.2

package/src/type/index.ts

@@ -1,9 +0,0 @@
-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/src/type/migration.ts

@@ -1,241 +0,0 @@
-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/src/type/namingStrategy.ts

@@ -1,17 +0,0 @@
-/**
- * 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/src/type/querier.ts

@@ -1,143 +0,0 @@
-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 function isSqlQuerier(querier: Querier): querier is SqlQuerier {
-  const q = querier as SqlQuerier;
-  return (
-    typeof q.all === 'function' &&
-    typeof q.run === 'function' &&
-    q.dialect !== undefined &&
-    typeof q.dialect.escapeIdChar === 'string'
-  );
-}
-
-/**
- * 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/src/type/querierPool.ts

@@ -1,26 +0,0 @@
-import type { Dialect, ExtraOptions, Querier } from './querier.js';
-
-/**
- * querier pool.
- */
-export type QuerierPool<Q extends Querier = Querier> = {
-  /**
-   * the database dialect.
-   */
-  readonly dialect: Dialect;
-
-  /**
-   * extra options
-   */
-  readonly extra?: ExtraOptions;
-
-  /**
-   * get a querier from the pool.
-   */
-  getQuerier: () => Promise<Q>;
-
-  /**
-   * end the pool.
-   */
-  end(): Promise<void>;
-};