ts-prorm-orm 1.1.0 → 1.2.1

package/dist/models/associations.d.ts

@@ -0,0 +1,131 @@
+/**
+ * Association classes for the ORM
+ * Supports hasOne, hasMany, belongsTo, and belongsToMany relationships
+ */
+import { ModelStatic, AssociationOptions, AssociationForeignKeyOptions, IncludeOptions, WhereOptions, Order } from '../types';
+declare abstract class BaseAssociation {
+    source: ModelStatic<any>;
+    target: ModelStatic<any>;
+    foreignKey: string | string[];
+    as: string;
+    type: 'belongsTo' | 'hasOne' | 'hasMany' | 'belongsToMany';
+    options: AssociationOptions;
+    constructor(source: ModelStatic<any>, target: ModelStatic<any>, options?: AssociationOptions);
+    abstract inferForeignKey(): string;
+    abstract getType(): 'belongsTo' | 'hasOne' | 'hasMany' | 'belongsToMany';
+    /**
+     * Get the association config for queries
+     */
+    getAssociationConfig(): AssociationConfig;
+}
+export interface AssociationConfig {
+    model: ModelStatic<any>;
+    as: string;
+    foreignKey: string | string[];
+    targetKey?: string | string[];
+    sourceKey?: string | string[];
+    constraints?: boolean;
+    onDelete?: string;
+    onUpdate?: string;
+}
+export interface NestedIncludeOptions extends IncludeOptions {
+    /**
+     * Nested includes - support for multi-level eager loading
+     */
+    include?: NestedIncludeOptions[];
+    /**
+     * Include all associations of this model
+     * Can be true to include all, or a string to filter by association name
+     */
+    all?: boolean | string;
+    /**
+     * Filter nested includes by association name(s)
+     */
+    nested?: boolean;
+    /**
+     * Whether to duplicate parent rows for each child (for hasMany)
+     */
+    duplicating?: boolean;
+}
+/**
+ * Flatten nested includes to a flat array with path information
+ */
+export declare class HasOneAssociation extends BaseAssociation {
+    constructor(source: ModelStatic<any>, target: ModelStatic<any>, options?: AssociationOptions);
+    inferForeignKey(): string;
+    getType(): 'hasOne';
+    /**
+     * Get the foreign key constraint SQL
+     */
+    getConstraintSql(tableName: string): string;
+}
+export declare class HasManyAssociation extends BaseAssociation {
+    constructor(source: ModelStatic<any>, target: ModelStatic<any>, options?: AssociationOptions);
+    inferForeignKey(): string;
+    getType(): 'hasMany';
+    /**
+     * Get the foreign key constraint SQL
+     */
+    getConstraintSql(tableName: string): string;
+}
+export declare class BelongsToAssociation extends BaseAssociation {
+    constructor(source: ModelStatic<any>, target: ModelStatic<any>, options?: AssociationOptions);
+    inferForeignKey(): string;
+    getType(): 'belongsTo';
+    /**
+     * Get the foreign key constraint SQL with onDelete and onUpdate support
+     */
+    getConstraintSql(tableName: string): string;
+    /**
+     * Get the full foreignKey options including allowNull from object form
+     */
+    getForeignKeyOptions(): AssociationForeignKeyOptions | undefined;
+}
+export declare class BelongsToManyAssociation extends BaseAssociation {
+    private through;
+    private throughModel;
+    private _otherKey;
+    constructor(source: ModelStatic<any>, target: ModelStatic<any>, options?: AssociationOptions);
+    inferForeignKey(): string;
+    getType(): 'belongsToMany';
+    getThrough(): string;
+    getOtherKey(): string;
+    setThroughModel(model: ModelStatic<any>): void;
+    getThroughModel(): ModelStatic<any> | null;
+}
+export interface HasOneMixin {
+    (target: ModelStatic<any>, options?: AssociationOptions): HasOneAssociation;
+}
+export interface HasManyMixin {
+    (target: ModelStatic<any>, options?: AssociationOptions): HasManyAssociation;
+}
+export interface BelongsToMixin {
+    (target: ModelStatic<any>, options?: AssociationOptions): BelongsToAssociation;
+}
+export interface BelongsToManyMixin {
+    (target: ModelStatic<any>, options?: AssociationOptions): BelongsToManyAssociation;
+}
+export declare function createAssociationMixins(source: ModelStatic<any>, sourceModelName: string, instancePrototype?: any): {
+    hasOne: HasOneMixin;
+    hasMany: HasManyMixin;
+    belongsTo: BelongsToMixin;
+    belongsToMany: BelongsToManyMixin;
+};
+/**
+ * Options for polymorphic associations
+ */
+export declare function processNestedIncludes(includes: IncludeOptions[], parentModel?: ModelStatic<any>, parentAlias?: string): Array<{
+    include: IncludeOptions;
+    parentAlias: string;
+    path: string;
+    nestedLevel: number;
+}>;
+export type { AssociationOptions, IncludeOptions, WhereOptions, Order };
+declare const _default: {
+    HasOneAssociation: typeof HasOneAssociation;
+    HasManyAssociation: typeof HasManyAssociation;
+    BelongsToAssociation: typeof BelongsToAssociation;
+    BelongsToManyAssociation: typeof BelongsToManyAssociation;
+    createAssociationMixins: typeof createAssociationMixins;
+};
+export default _default;

package/dist/models/associations.js

@@ -99,8 +99,13 @@ class HasOneAssociation extends BaseAssociation {
         super(source, target, options);
     }
     inferForeignKey() {
-        // Default foreign key is target model name + Id (e.g., userId)
-        return `${lowerFirst(this.target.name)}Id`;
+        // For hasOne the foreign key lives on the TARGET table and names the SOURCE
+        // model - `User.hasOne(Profile)` means `profiles.userId`. This previously
+        // derived from `this.target`, producing `profileId` on `profiles`: a
+        // self-referential column that is never populated, so the association always
+        // resolved to null. `hasMany` (below) and the eager-loader's own fallback in
+        // prorm.ts both derive from the source; this is the one place that didn't.
+        return `${lowerFirst(this.source.name)}Id`;
     }
     getType() {
         return 'hasOne';

package/dist/models/constraints.d.ts

@@ -0,0 +1,175 @@
+/**
+ * Constraint management for the TypeScript ORM
+ * Handles constraint creation for PRIMARY KEY, UNIQUE, FOREIGN KEY, and CHECK constraints
+ */
+/**
+ * Foreign key reference options
+ */
+export interface ForeignKeyReference {
+    table: string;
+    field: string;
+    /** Composite key fields on referenced table */
+    fields?: string[];
+    onDelete?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+    onUpdate?: 'CASCADE' | 'RESTRICT' | 'SET NULL' | 'NO ACTION' | 'SET DEFAULT';
+    deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' | 'NOT DEFERRABLE';
+    /** Match type for foreign key (PostgreSQL) */
+    match?: 'FULL' | 'PARTIAL' | 'SIMPLE';
+}
+/**
+ * Constraint field definition
+ */
+export interface ConstraintField {
+    name: string;
+    length?: number;
+    order?: 'ASC' | 'DESC';
+}
+/**
+ * Constraint type enumeration
+ */
+export type ConstraintType = 'PRIMARY KEY' | 'UNIQUE' | 'FOREIGN KEY' | 'CHECK' | 'EXCLUDE';
+/**
+ * Options for creating a constraint
+ */
+export interface ConstraintOptions {
+    /** Custom constraint name (auto-generated if not provided) */
+    name?: string;
+    /** Alias for name - custom constraint name */
+    constraintName?: string;
+    type: ConstraintType;
+    /** Single field or array of fields for composite constraints */
+    fields?: string[] | ConstraintField[];
+    references?: ForeignKeyReference;
+    where?: Record<string, any>;
+    check?: string;
+    /** PostgreSQL: deferrable constraint */
+    deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' | 'NOT DEFERRABLE';
+    initiallyDeferred?: boolean;
+    /** Foreign key match type (FULL, PARTIAL) */
+    match?: 'FULL' | 'PARTIAL';
+}
+/**
+ * Generate a unique constraint name
+ */
+export declare function generateConstraintName(type: ConstraintType, tableName: string, fields: string[]): string;
+/**
+ * Constraint class representing a database constraint
+ */
+export declare class Constraint {
+    readonly name: string;
+    readonly type: ConstraintType;
+    readonly fields: string[] | ConstraintField[];
+    readonly references?: ForeignKeyReference;
+    readonly where?: Record<string, any>;
+    readonly check?: string;
+    readonly deferrable?: 'INITIALLY DEFERRED' | 'INITIALLY IMMEDIATE' | 'NOT DEFERRABLE';
+    readonly match?: 'FULL' | 'PARTIAL';
+    readonly tableName?: string;
+    constructor(options: ConstraintOptions & {
+        tableName?: string;
+    });
+    /**
+     * Get field names as string array
+     */
+    getFieldNames(): string[];
+    /**
+     * Check if this is a composite constraint
+     */
+    isComposite(): boolean;
+    /**
+     * Convert to plain object
+     */
+    toJSON(): ConstraintOptions & {
+        tableName?: string;
+    };
+}
+/**
+ * Constraint collection for managing multiple constraints
+ */
+export declare class ConstraintCollection {
+    private constraints;
+    /**
+     * Add a constraint to the collection
+     */
+    addConstraint(constraint: Constraint): void;
+    /**
+     * Get a constraint by name
+     */
+    getConstraint(name: string): Constraint | undefined;
+    /**
+     * Get all constraints
+     */
+    getAllConstraints(): Constraint[];
+    /**
+     * Get constraints by type
+     */
+    getConstraintsByType(type: ConstraintType): Constraint[];
+    /**
+     * Remove a constraint by name
+     */
+    removeConstraint(name: string): boolean;
+    /**
+     * Check if a constraint exists
+     */
+    hasConstraint(name: string): boolean;
+    /**
+     * Get the number of constraints
+     */
+    get size(): number;
+    /**
+     * Clear all constraints
+     */
+    clear(): void;
+}
+/**
+ * Build a primary key constraint
+ */
+export declare function buildPrimaryKeyConstraint(tableName: string, fields: string[], constraintName?: string, dialect?: 'postgres' | 'mysql' | 'sqlite' | 'mariadb'): string;
+/**
+ * Build a unique constraint
+ */
+export declare function buildUniqueConstraint(tableName: string, fields: string[], constraintName?: string, dialect?: 'postgres' | 'mysql' | 'sqlite' | 'mariadb'): string;
+/**
+ * Build a foreign key constraint
+ */
+export declare function buildForeignKeyConstraint(tableName: string, fields: string[], references: ForeignKeyReference, constraintName?: string, dialect?: 'postgres' | 'mysql' | 'sqlite' | 'mariadb'): string;
+/**
+ * Build a check constraint
+ */
+export declare function buildCheckConstraint(tableName: string, check: string, constraintName?: string, dialect?: 'postgres' | 'mysql' | 'sqlite' | 'mariadb'): string;
+/**
+ * Build constraint SQL for a specific dialect
+ */
+export declare function buildConstraintSQL(dialect: 'postgres' | 'mysql' | 'sqlite' | 'mariadb', constraint: Constraint, tableName: string): string;
+/**
+ * Normalize fields to string array
+ */
+export declare function normalizeConstraintFields(fields: string[] | ConstraintField[]): string[];
+/**
+ * Create a primary key constraint
+ */
+export declare function primaryKey(fields: string[] | ConstraintField[], options?: {
+    name?: string;
+    tableName?: string;
+}): Constraint;
+/**
+ * Create a unique constraint
+ */
+export declare function unique(fields: string[] | ConstraintField[], options?: {
+    name?: string;
+    tableName?: string;
+}): Constraint;
+/**
+ * Create a foreign key constraint
+ */
+export declare function foreignKey(fields: string[] | ConstraintField[], references: ForeignKeyReference, options?: {
+    name?: string;
+    tableName?: string;
+}): Constraint;
+/**
+ * Create a check constraint
+ */
+export declare function check(check: string, options?: {
+    name?: string;
+    tableName?: string;
+}): Constraint;