@rvoh/dream 0.29.1

package/dist/types/src/bin/helpers/sync.d.ts

@@ -0,0 +1,2 @@
+import '../../helpers/loadEnv.js';
+export default function writeSyncFile(): Promise<void>;

package/dist/types/src/bin/index.d.ts

@@ -0,0 +1,20 @@
+import '../helpers/loadEnv.js';
+export default class DreamBin {
+    static sync(onSync: () => Promise<void> | void): Promise<void>;
+    static buildDreamSchema(): Promise<void>;
+    static dbCreate(): Promise<void>;
+    static dbDrop(): Promise<void>;
+    static dbMigrate(): Promise<void>;
+    static dbRollback(opts: {
+        steps: number;
+    }): Promise<void>;
+    static generateDream(fullyQualifiedModelName: string, columnsWithTypes: string[], options: {
+        serializer: boolean;
+    }): Promise<void>;
+    static generateStiChild(fullyQualifiedModelName: string, fullyQualifiedParentName: string, columnsWithTypes: string[], options: {
+        serializer: boolean;
+    }): Promise<void>;
+    static generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
+    private static buildDocs;
+    private static duplicateDatabase;
+}

package/dist/types/src/cli/index.d.ts

@@ -0,0 +1,20 @@
+import { Command } from 'commander';
+import DreamApplication, { DreamApplicationInitOptions } from '../dream-application/index.js';
+export default class DreamCLI {
+    /**
+     * use this method for initializing a standalone dream application. If using Psychic and Dream together,
+     * a different pattern is used, which leverages the `generateDreamCli` method instead.
+     */
+    static provide(program: Command, { initializeDreamApplication, seedDb, }: {
+        initializeDreamApplication: (opts?: DreamApplicationInitOptions) => Promise<DreamApplication>;
+        seedDb: () => Promise<void> | void;
+    }): void;
+    /**
+     * called under the hood when provisioning both psychic and dream applications.
+     */
+    static generateDreamCli(program: Command, { initializeDreamApplication, seedDb, onSync, }: {
+        initializeDreamApplication: (opts?: DreamApplicationInitOptions) => Promise<any>;
+        seedDb: () => Promise<void> | void;
+        onSync: () => Promise<void> | void;
+    }): void;
+}

package/dist/types/src/db/ConnectedToDB.d.ts

@@ -0,0 +1,26 @@
+import { Kysely, Transaction as KyselyTransaction } from 'kysely';
+import Dream from '../Dream.js';
+import DreamTransaction from '../dream/DreamTransaction.js';
+import { DreamConstructorType, SqlCommandType } from '../dream/types.js';
+import { DbConnectionType } from './types.js';
+export default class ConnectedToDB<DreamInstance extends Dream> {
+    dreamInstance: DreamInstance;
+    protected readonly dreamClass: DreamConstructorType<DreamInstance>;
+    protected dreamTransaction: DreamTransaction<Dream> | null;
+    protected connectionOverride?: DbConnectionType;
+    /**
+     * @internal
+     *
+     * stores the Dream models joined in this Query instance
+     */
+    protected readonly innerJoinDreamClasses: readonly (typeof Dream)[];
+    constructor(dreamInstance: DreamInstance, opts?: ConnectedToDBOpts);
+    dbConnectionType(sqlCommandType: SqlCommandType): DbConnectionType;
+    dbFor(sqlCommandType: SqlCommandType): Kysely<DreamInstance['DB']> | KyselyTransaction<DreamInstance['DB']>;
+    private isReplicaSafe;
+}
+export interface ConnectedToDBOpts {
+    transaction?: DreamTransaction<Dream> | null | undefined;
+    connection?: DbConnectionType;
+    innerJoinDreamClasses?: readonly (typeof Dream)[];
+}

package/dist/types/src/db/ConnectionConfRetriever.d.ts

@@ -0,0 +1,6 @@
+import { SingleDbCredential } from '../dream-application/index.js';
+import { DbConnectionType } from './types.js';
+export default class ConnectionConfRetriever {
+    getConnectionConf(connection: DbConnectionType): SingleDbCredential;
+    hasReplicaConfig(): boolean;
+}

package/dist/types/src/db/DreamDbConnection.d.ts

@@ -0,0 +1,10 @@
+import { Kysely } from 'kysely';
+import { DbConnectionType } from './types.js';
+export default class DreamDbConnection {
+    static getConnection<DB>(connectionType: DbConnectionType): Kysely<DB>;
+    static dropAllConnections(): Promise<void>;
+}
+export declare function dreamDbConnections(): {
+    [key: string]: Kysely<any>;
+};
+export declare function closeAllDbConnections(): Promise<void>;

package/dist/types/src/db/dataTypes.d.ts

@@ -0,0 +1,6 @@
+export default function dataTypes(): readonly ["bigint", "bigserial", "bit", "bit varying", "boolean", "box", "bytea", "character", "character varying", "char", "cidr", "circle", "citext", "date", "double precision", "inet", "integer", "interval", "json", "jsonb", "line", "lseg", "macaddr", "money", "numeric", "path", "point", "polygon", "real", "smallint", "smallserial", "serial", "text", "time", "time with time zone", "timestamp", "timestamp with time zone", "timestamp without time zone", "tsquery", "tsvector", "txid_snapshot", "uuid", "xml"];
+export declare function isPrimitiveDataType(type: string): boolean;
+export declare const postgresDatatypes: readonly ["bigint", "bigserial", "bit", "bit varying", "boolean", "box", "bytea", "character", "character varying", "char", "cidr", "circle", "citext", "date", "double precision", "inet", "integer", "interval", "json", "jsonb", "line", "lseg", "macaddr", "money", "numeric", "path", "point", "polygon", "real", "smallint", "smallserial", "serial", "text", "time", "time with time zone", "timestamp", "timestamp with time zone", "timestamp without time zone", "tsquery", "tsvector", "txid_snapshot", "uuid", "xml"];
+type NonArrayDbTypes = (typeof postgresDatatypes)[number];
+export type DbTypes = NonArrayDbTypes | `${NonArrayDbTypes}[]`;
+export {};

package/dist/types/src/db/errors.d.ts

@@ -0,0 +1,6 @@
+export declare const PG_ERRORS: {
+    readonly 23505: "UNIQUE_CONSTRAINT_VIOLATION";
+};
+type PgErrorType = (typeof PG_ERRORS)[keyof typeof PG_ERRORS];
+export declare function pgErrorType(error: any): PgErrorType | null;
+export {};

package/dist/types/src/db/index.d.ts

@@ -0,0 +1,5 @@
+import { Kysely } from 'kysely';
+import Dream from '../Dream.js';
+import '../helpers/loadEnv.js';
+import { DbConnectionType } from './types.js';
+export default function db<T extends Dream, DB extends T['DB'] = T['DB']>(connectionType?: DbConnectionType): Kysely<DB>;

package/dist/types/src/db/migration-helpers/DreamMigrationHelpers.d.ts

@@ -0,0 +1,116 @@
+import { Kysely } from 'kysely';
+export default class DreamMigrationHelpers {
+    /**
+     * Unique indexes cannot be populated by the same value even within a transaction,
+     * but deferrable unique constraints can.
+     *
+     * The Sortable decorator requires deferrable unique constraints rather than unique
+     * indexes.
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param constraintName - The name of the constraint to create
+     * @param opts.table - The name of the table
+     * @param opts.columns[] - The names of the columns to include in the constraint
+     *
+     */
+    static addDeferrableUniqueConstraint(db: Kysely<any>, constraintName: string, { table, columns, }: {
+        table: string;
+        columns: string[];
+    }): Promise<void>;
+    /**
+     * Add a value to an enum.
+     *
+     * Note that this always includes "IF NOT EXISTS", so is safe to re-run multiple times.
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param opt.enumName - The name of the enum to modify
+     * @param opt.value - The name of the value to add to the enum
+     *
+     */
+    static addEnumValue(db: Kysely<any>, { enumName, value }: AddValueToEnumOpts): Promise<void>;
+    /**
+     * Create a database extension.
+     *
+     * ```
+     *   // Add the case insensitive extension
+     *   await DreamMigrationHelpers.createExtension(db, 'citext')
+     *
+     *   // Add the pg trigram extension
+     *   await DreamMigrationHelpers.createExtension(db, 'pg_trgm')
+     * ```
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param extensionName - The name of the database extension to add
+     * @param opt.ifNotExists - Only add the extension if it doesn't already exist
+     * @param opt.publicSchema - Create using the public schema
+     *
+     */
+    static createExtension(db: Kysely<any>, extensionName: string, { ifNotExists, publicSchema }?: {
+        ifNotExists?: boolean;
+        publicSchema?: boolean;
+    }): Promise<void>;
+    /**
+     * Create a gin index
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param indexName - The name of the constraint to create
+     * @param opts.table - The name of the table
+     * @param opts.column - The name of the column to index
+     *
+     */
+    static createGinIndex(db: Kysely<any>, indexName: string, { table, column }: {
+        table: string;
+        column: string;
+    }): Promise<void>;
+    /**
+     * Drop a constraint
+     *
+     * Note that this always includes "IF NOT EXISTS", so is safe to re-run multiple times.
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param constraintName - The name of the constraint to create
+     * @param opts.table - The name of the table
+     *
+     */
+    static dropConstraint(db: Kysely<any>, constraintName: string, { table }: {
+        table: string;
+    }): Promise<void>;
+    /**
+     * Drop a value from an enum and replace it (or optionally remove it from array columns)
+     *
+     * @param db - The Kysely database object passed into the migration up/down function
+     * @param opt.enumName - The name of the enum to modify
+     * @param opt.value - The name of the value to drop from the enum
+     * @param opt.replacements[] - Details about which table and column to change and which value to replace the dropped value with (or remove it if the column is an array)
+     *
+     */
+    static dropEnumValue(db: Kysely<any>, { enumName, value, replacements }: DropValueFromEnumOpts): Promise<void>;
+}
+interface DropValueFromEnumOpts {
+    enumName: string;
+    value: string;
+    replacements: DropValueFromEnumTablesAndColumns[];
+}
+type DropValueFromEnumTablesAndColumns = DropValueWithRemovalFromEnumTablesAndColumnsForArray | DropValueWithReplacementFromEnumTablesAndColumnsForArray | DropValueFromEnumTablesAndColumnsForNonArray;
+interface DropValueFromEnumTablesAndColumnsForArrayBase {
+    table: string;
+    column: string;
+    array: true;
+}
+interface DropValueWithRemovalFromEnumTablesAndColumnsForArray extends DropValueFromEnumTablesAndColumnsForArrayBase {
+    behavior: 'replace';
+    replaceWith: string;
+}
+interface DropValueWithReplacementFromEnumTablesAndColumnsForArray extends DropValueFromEnumTablesAndColumnsForArrayBase {
+    behavior: 'remove';
+}
+type DropValueFromEnumTablesAndColumnsForNonArray = {
+    table: string;
+    column: string;
+    replaceWith: string | null;
+};
+interface AddValueToEnumOpts {
+    enumName: string;
+    value: string;
+}
+export {};

package/dist/types/src/db/reflections.d.ts

@@ -0,0 +1,5 @@
+export type AssociationTableNames<DB, Schema> = keyof DB & keyof Schema extends never ? unknown : keyof DB & keyof Schema & string;
+export type Tables<DB> = keyof DB;
+export type TableInterfaces<DB> = valueof<DB>;
+type valueof<T> = T[keyof T];
+export {};

package/dist/types/src/db/types.d.ts

@@ -0,0 +1 @@
+export type DbConnectionType = 'primary' | 'replica';

package/dist/types/src/db/validators/validateColumn.d.ts

@@ -0,0 +1 @@
+export default function validateColumn<Schema, TableName extends keyof Schema & string>(schema: Schema, tableName: TableName, columnName: keyof Schema[TableName]['columns' & keyof Schema[TableName]] & string): keyof Schema[TableName]["columns" & keyof Schema[TableName]] & string;

package/dist/types/src/db/validators/validateTable.d.ts

@@ -0,0 +1 @@
+export default function validateTable<Schema, TableName extends keyof Schema & string>(schema: Schema, tableName: TableName): TableName;

package/dist/types/src/db/validators/validateTableAlias.d.ts

@@ -0,0 +1 @@
+export default function validateTableAlias(tableAlias: string): string;

package/dist/types/src/decorators/DecoratorContextType.d.ts

@@ -0,0 +1,13 @@
+export interface DecoratorContext {
+    kind: 'class' | 'field' | 'method';
+    name: string;
+    static: boolean;
+    private: boolean;
+    access: {
+        has: () => unknown;
+        get: () => unknown;
+        set: () => unknown;
+    };
+    metadata: unknown;
+    addInitializer: (arg: (this: any) => void) => void;
+}

package/dist/types/src/decorators/Decorators.d.ts

@@ -0,0 +1,214 @@
+import Dream from '../Dream.js';
+import { GlobalModelNameTableMap, SortableOptions } from '../dream/types.js';
+import { NonPolymorphicBelongsToOptions, PolymorphicBelongsToOptions } from './associations/BelongsTo.js';
+import { HasManyOptions, HasManyThroughOptions, PolymorphicHasManyOptions } from './associations/HasMany.js';
+import { HasOneOptions, HasOneThroughOptions, PolymorphicHasOneOptions } from './associations/HasOne.js';
+import { AfterHookOpts, BeforeHookOpts } from './hooks/shared.js';
+export default class Decorators<T extends Dream> {
+    BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: NonPolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
+    BelongsTo<const AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<T> | (keyof GlobalModelNameTableMap<T>)[]>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalNameOrNames, options?: PolymorphicBelongsToOptions<T, AssociationGlobalNameOrNames>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyOptions<T, AssociationGlobalName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasManyThroughOptions<T, AssociationGlobalName>): any;
+    HasMany<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasManyOptions<T, AssociationGlobalName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneOptions<T, AssociationGlobalName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: HasOneThroughOptions<T, AssociationGlobalName>): any;
+    HasOne<const AssociationGlobalName extends keyof GlobalModelNameTableMap<T>>(this: Decorators<T>, globalAssociationNameOrNames: AssociationGlobalName, options?: PolymorphicHasOneOptions<T, AssociationGlobalName>): any;
+    /**
+     * Shortcut to the Sortable decorator, which also provides extra type protection which cannot be provided
+     * with the Sortable decorator.
+     *
+     * @param scope - The column, association, or combination there-of which you would like to restrict the incrementing logic to
+     * @returns A Sortable decorator
+     */
+    Sortable(this: Decorators<T>, opts?: SortableOptions<T>): any;
+    /**
+     * Shortcut to the BeforeCreate decorator
+     *
+     * ```ts
+     * class User {
+     *   User.BeforeCreate()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The BeforeCreate decorator
+     *
+     */
+    BeforeCreate(this: Decorators<T>, opts?: BeforeHookOpts<T>): any;
+    /**
+     * Shortcut to the BeforeSave decorator
+     *
+     * ```ts
+     * class User {
+     *   User.BeforeSave()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The BeforeSave decorator
+     *
+     */
+    BeforeSave(this: Decorators<T>, opts?: BeforeHookOpts<T>): any;
+    /**
+     * Shortcut to the BeforeUpdate decorator
+     *
+     * ```ts
+     * class User {
+     *   User.BeforeUpdate()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The BeforeUpdate decorator
+     *
+     */
+    BeforeUpdate(this: Decorators<T>, opts?: BeforeHookOpts<T>): any;
+    /**
+     * Shortcut to the BeforeDestroy decorator
+     *
+     * ```ts
+     * class User {
+     *   User.BeforeDestroy()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The BeforeDestroy decorator
+     */
+    BeforeDestroy(this: Decorators<T>): any;
+    /**
+     * Shortcut to the AfterCreate decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterCreate()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterCreate decorator
+     *
+     */
+    AfterCreate(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    /**
+     * Shortcut to the AfterCreateCommit decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterCreateCommit()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterCreateCommit decorator
+     */
+    AfterCreateCommit(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    /**
+     * Shortcut to the AfterSave decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterSave()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterSave decorator
+     *
+     */
+    AfterSave(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    /**
+     * Shortcut to the AfterSaveCommit decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterSaveCommit()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterSaveCommit decorator
+     *
+     */
+    AfterSaveCommit(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    /**
+     * Shortcut to the AfterUpdate decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterUpdate()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterUpdate decorator
+     *
+     */
+    AfterUpdate(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    /**
+     * Shortcut to the AfterUpdateCommit decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterUpdateCommit()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterUpdateCommit decorator
+     *
+     */
+    AfterUpdateCommit(this: Decorators<T>, opts?: AfterHookOpts<T>): any;
+    /**
+     * Shortcut to the AfterDestroy decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterDestroy()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterDestroy decorator
+     *
+     */
+    AfterDestroy(this: Decorators<T>): any;
+    /**
+     * Shortcut to the AfterDestroyCommit decorator
+     *
+     * ```ts
+     * class User {
+     *   User.AfterDestroyCommit()
+     *   public doSomething() {
+     *     console.log('hi!')
+     *   }
+     * }
+     * ```
+     *
+     * @returns The AfterDestroyCommit decorator
+     *
+     */
+    AfterDestroyCommit(this: Decorators<T>): any;
+}

package/dist/types/src/decorators/Encrypted.d.ts

@@ -0,0 +1,5 @@
+export default function Encrypted(encryptedColumnName?: string): any;
+export interface EncryptedAttributeStatement {
+    property: string;
+    encryptedColumnName: string;
+}

package/dist/types/src/decorators/ReplicaSafe.d.ts

@@ -0,0 +1 @@
+export default function ReplicaSafe(): ClassDecorator;

package/dist/types/src/decorators/STI.d.ts

@@ -0,0 +1,5 @@
+import Dream from '../Dream.js';
+export declare const STI_SCOPE_NAME = "dream:STI";
+export default function STI(dreamClass: typeof Dream, { value }?: {
+    value?: string;
+}): ClassDecorator;

package/dist/types/src/decorators/Scope.d.ts

@@ -0,0 +1,11 @@
+import Dream from '../Dream.js';
+export default function Scope(opts?: {
+    default?: boolean;
+}): any;
+export declare function scopeImplementation(t: typeof Dream, key: string, opts?: {
+    default?: boolean;
+}): void;
+export interface ScopeStatement {
+    method: string;
+    default: boolean;
+}

package/dist/types/src/decorators/SoftDelete.d.ts

@@ -0,0 +1,37 @@
+export declare const SOFT_DELETE_SCOPE_NAME = "dream:SoftDelete";
+/**
+ * Instructs the model to set a timestamp when deleting,
+ * rather than actually removing the record from the
+ * database.
+ *
+ * By default, the SoftDelete decorator will expect a
+ * `deletedAt` field to be set on your model, pointing
+ * to a `timestamp` field in the database, like so:
+ *
+ * ```ts
+ * export async function up(db: Kysely<any>): Promise<void> {
+ *   await db.schema
+ *     .createTable('posts')
+ *     .addColumn('id', 'bigserial', col => col.primaryKey())
+ *     .addColumn('deleted_at', 'timestamp', col => col.defaultTo(null))
+ *     .addColumn('created_at', 'timestamp', col => col.notNull())
+ *     .addColumn('updated_at', 'timestamp', col => col.notNull())
+ *     .execute()
+ * }
+ *
+ * @SoftDelete()
+ * class Post extends ApplicationModel {}
+ * ```
+ *
+ * If you would like to use a different column to hold the
+ * deleted status, you can specify a custom column in your model,
+ * like so:
+ *
+ * @SoftDelete()
+ * class Post extends ApplicationModel {
+ *   public get deletedAtField() {
+ *     return 'customDatetimeField' as const
+ *   }
+ * }
+ */
+export default function SoftDelete(): ClassDecorator;

package/dist/types/src/decorators/Virtual.d.ts

@@ -0,0 +1,6 @@
+import { SerializableTypes } from '../serializer/decorators/attribute.js';
+export default function Virtual(type?: SerializableTypes): any;
+export interface VirtualAttributeStatement {
+    property: string;
+    type?: SerializableTypes;
+}

package/dist/types/src/decorators/associations/BelongsTo.d.ts

@@ -0,0 +1,33 @@
+import { AssociationTableNames } from '../../db/reflections.js';
+import Dream from '../../Dream.js';
+import { DefaultScopeName, DefaultScopeNameForTable, DreamColumnNames, GlobalModelNames, GlobalModelNameTableMap, TableColumnNames, TableNameForGlobalModelName } from '../../dream/types.js';
+export default function BelongsTo<BaseInstance extends Dream, AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<BaseInstance> | (keyof GlobalModelNameTableMap<BaseInstance>)[]>(globalAssociationNameOrNames: AssociationGlobalNameOrNames, opts?: NonPolymorphicBelongsToOptions<BaseInstance, AssociationGlobalNameOrNames>): any;
+export default function BelongsTo<BaseInstance extends Dream, AssociationGlobalNameOrNames extends keyof GlobalModelNameTableMap<BaseInstance> | (keyof GlobalModelNameTableMap<BaseInstance>)[]>(globalAssociationNameOrNames: AssociationGlobalNameOrNames, opts?: PolymorphicBelongsToOptions<BaseInstance, AssociationGlobalNameOrNames>): any;
+export interface BelongsToStatement<BaseInstance extends Dream, DB, Schema, TableName extends AssociationTableNames<DB, Schema> & keyof DB> {
+    modelCB: () => typeof Dream | (typeof Dream)[];
+    globalAssociationNameOrNames: string[];
+    type: 'BelongsTo';
+    as: string;
+    primaryKey: (associationInstance?: Dream) => keyof DB[TableName] & string;
+    primaryKeyValue: (associationInstance: Dream | null) => any;
+    primaryKeyOverride?: (keyof DB[TableName] & string) | null;
+    foreignKey: () => DreamColumnNames<BaseInstance> & string;
+    foreignKeyTypeField: () => DreamColumnNames<BaseInstance> & string;
+    optional: boolean;
+    distinct: null;
+    polymorphic: boolean;
+    withoutDefaultScopes?: DefaultScopeName<BaseInstance>[];
+}
+export interface NonPolymorphicBelongsToOptions<BaseInstance extends Dream, AssociationGlobalNameOrNames extends GlobalModelNames<BaseInstance> | readonly GlobalModelNames<BaseInstance>[], AssociationGlobalName = AssociationGlobalNameOrNames extends Readonly<any[]> ? AssociationGlobalNameOrNames[0] & string : AssociationGlobalNameOrNames & string, AssociationTableName extends AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB'] = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & GlobalModelNames<BaseInstance>> & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> {
+    foreignKey?: DreamColumnNames<BaseInstance>;
+    primaryKeyOverride?: TableColumnNames<BaseInstance['DB'], AssociationTableName> | null;
+    optional?: boolean;
+    withoutDefaultScopes?: DefaultScopeNameForTable<BaseInstance['schema'], AssociationTableName>[];
+}
+export interface PolymorphicBelongsToOptions<BaseInstance extends Dream, AssociationGlobalNameOrNames extends GlobalModelNames<BaseInstance> | readonly GlobalModelNames<BaseInstance>[], AssociationGlobalName = AssociationGlobalNameOrNames extends Readonly<any[]> ? AssociationGlobalNameOrNames[0] & string : AssociationGlobalNameOrNames & string, AssociationTableName extends AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB'] = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & GlobalModelNames<BaseInstance>> & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> {
+    foreignKey: DreamColumnNames<BaseInstance>;
+    primaryKeyOverride?: TableColumnNames<BaseInstance['DB'], AssociationTableName> | null;
+    optional?: boolean;
+    polymorphic: boolean;
+    withoutDefaultScopes?: DefaultScopeNameForTable<BaseInstance['schema'], AssociationTableName>[];
+}

package/dist/types/src/decorators/associations/HasMany.d.ts

@@ -0,0 +1,19 @@
+import { AssociationTableNames } from '../../db/reflections.js';
+import Dream from '../../Dream.js';
+import { GlobalModelNames, GlobalModelNameTableMap, TableColumnNames, TableNameForGlobalModelName } from '../../dream/types.js';
+import { HasOptions, HasStatement, HasThroughOptions, OrderStatement, PolymorphicHasOptions } from './shared.js';
+export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyOptions<BaseInstance, AssociationGlobalName>): any;
+export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasManyThroughOptions<BaseInstance, AssociationGlobalName>): any;
+export default function HasMany<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasManyOptions<BaseInstance, AssociationGlobalName>): any;
+export type HasManyStatement<BaseInstance extends Dream, DB, Schema, ForeignTableName extends AssociationTableNames<DB, Schema> & keyof DB> = HasStatement<BaseInstance, DB, Schema, ForeignTableName, 'HasMany'> & {
+    distinct?: TableColumnNames<DB, ForeignTableName>;
+    order?: OrderStatement<DB, Schema, ForeignTableName>;
+};
+interface HasManyOnlyOptions<BaseInstance extends Dream, AssociationGlobalNameOrNames extends GlobalModelNames<BaseInstance> | readonly GlobalModelNames<BaseInstance>[], AssociationGlobalName = AssociationGlobalNameOrNames extends any[] ? AssociationGlobalNameOrNames[0] & string : AssociationGlobalNameOrNames & string, AssociationTableName = TableNameForGlobalModelName<BaseInstance, AssociationGlobalName & GlobalModelNames<BaseInstance>>> {
+    distinct?: TableColumnNames<BaseInstance['DB'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> | boolean;
+    order?: OrderStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']> | OrderStatement<BaseInstance['DB'], BaseInstance['schema'], AssociationTableName & AssociationTableNames<BaseInstance['DB'], BaseInstance['schema']> & keyof BaseInstance['DB']>[];
+}
+export type HasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
+export type PolymorphicHasManyOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
+export type HasManyThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasThroughOptions<BaseInstance, AssociationGlobalName> & HasManyOnlyOptions<BaseInstance, AssociationGlobalName>;
+export {};

package/dist/types/src/decorators/associations/HasOne.d.ts

@@ -0,0 +1,11 @@
+import { AssociationTableNames } from '../../db/reflections.js';
+import Dream from '../../Dream.js';
+import { GlobalModelNameTableMap } from '../../dream/types.js';
+import { HasOptions, HasStatement, HasThroughOptions, PolymorphicHasOptions } from './shared.js';
+export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationName: AssociationGlobalName, opts?: HasOneOptions<BaseInstance, AssociationGlobalName>): any;
+export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: HasOneThroughOptions<BaseInstance, AssociationGlobalName>): any;
+export default function HasOne<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>>(globalAssociationNameOrNames: AssociationGlobalName, opts?: PolymorphicHasOneOptions<BaseInstance, AssociationGlobalName>): any;
+export type HasOneStatement<BaseInstance extends Dream, DB, Schema, ForeignTableName extends AssociationTableNames<DB, Schema> & keyof DB> = HasStatement<BaseInstance, DB, Schema, ForeignTableName, 'HasOne'>;
+export type HasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasOptions<BaseInstance, AssociationGlobalName>;
+export type PolymorphicHasOneOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = PolymorphicHasOptions<BaseInstance, AssociationGlobalName>;
+export type HasOneThroughOptions<BaseInstance extends Dream, AssociationGlobalName extends keyof GlobalModelNameTableMap<BaseInstance>> = HasThroughOptions<BaseInstance, AssociationGlobalName>;

package/dist/types/src/decorators/associations/associationToGetterSetterProp.d.ts

@@ -0,0 +1,5 @@
+import { BelongsToStatement } from './BelongsTo.js';
+import { HasManyStatement } from './HasMany.js';
+import { HasOneStatement } from './HasOne.js';
+import { PartialAssociationStatement } from './shared.js';
+export default function associationToGetterSetterProp(association: BelongsToStatement<any, any, any, any> | HasManyStatement<any, any, any, any> | HasOneStatement<any, any, any, any> | PartialAssociationStatement): string;