@rvoh/dream 0.44.6 → 0.44.8

package/dist/esm/src/dream/QueryDriver/Postgres.js

@@ -0,0 +1,3 @@
+import KyselyQueryDriver from './Kysely.js';
+export default class PostgresQueryDriver extends KyselyQueryDriver {
+}

package/dist/esm/src/dream/internal/saveDream.js

@@ -1,12 +1,9 @@
-import _db from '../../db/index.js';
 import ValidationError from '../../errors/ValidationError.js';
 import { DateTime } from '../../helpers/DateTime.js';
-import namespaceColumn from '../../helpers/namespaceColumn.js';
 import sqlAttributes from '../../helpers/sqlAttributes.js';
-import executeDatabaseQuery from './executeDatabaseQuery.js';
+import Query from '../Query.js';
 import runHooksFor from './runHooksFor.js';
 export default async function saveDream(dream, txn = null, { skipHooks = false } = {}) {
-    const db = txn?.kyselyTransaction ?? _db('primary');
     const alreadyPersisted = dream.isPersisted;
     if (!skipHooks) {
         if (alreadyPersisted)
@@ -22,26 +19,16 @@ export default async function saveDream(dream, txn = null, { skipHooks = false }
         throw new ValidationError(dream['sanitizedConstructorName'], dream.errors);
     if (alreadyPersisted && !dream.isDirty)
         return dream;
-    let query;
     const now = DateTime.now();
     if (!alreadyPersisted && !dream.createdAt && dream.columns().has('createdAt'))
         dream.createdAt = now;
     if (!dream.dirtyAttributes().updatedAt && dream.columns().has('updatedAt'))
         dream.updatedAt = now;
-    const sqlifiedAttributes = sqlAttributes(dream);
-    if (alreadyPersisted) {
-        query = db
-            .updateTable(dream.table)
-            .set(sqlifiedAttributes)
-            .where(namespaceColumn(dream.primaryKey, dream.table), '=', dream.primaryKeyValue);
-    }
-    else {
-        query = db.insertInto(dream.table).values(sqlifiedAttributes);
-    }
+    const hasUnsavedData = !!Object.keys(sqlAttributes(dream)).length;
     // BeforeSave/Update actions may clear all the data that we intended to save, leaving us with
     // an invalid update command. The Sortable decorator is an example of this.
-    if (!alreadyPersisted || Object.keys(sqlifiedAttributes).length) {
-        const data = await executeDatabaseQuery(query.returning([...dream.columns()]), 'executeTakeFirstOrThrow');
+    if (!alreadyPersisted || hasUnsavedData) {
+        const data = await Query.dbDriverClass().saveDream(dream, txn);
         dream['isPersisted'] = true;
         dream.setAttributes(data);
     }

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

@@ -1,6 +1,5 @@
 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>;
@@ -16,5 +15,4 @@ export default class DreamBin {
     }): Promise<void>;
     static generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
     private static buildDocs;
-    private static duplicateDatabase;
 }

package/dist/types/src/dream/Query.d.ts

@@ -1,13 +1,13 @@
 import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
-import ConnectedToDB from '../db/ConnectedToDB.js';
 import Dream from '../Dream.js';
 import { ColumnNamesAccountingForJoinedAssociations, LimitStatement, OffsetStatement, OrderQueryStatement, PassthroughOnClause, WhereStatement, WhereStatementForJoinedAssociation } from '../types/associations/shared.js';
 import { DbConnectionType } from '../types/db.js';
-import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
+import { AllDefaultScopeNames, DefaultScopeName, DreamColumnNames, DreamConstructorType, DreamTableSchema, OrderDir, PassthroughColumnNames, PluckEachArgs, PrimaryKeyForFind, RelaxedJoinAndStatement, RelaxedJoinStatement, RelaxedPreloadOnStatement, RelaxedPreloadStatement, TableColumnNames, TableOrAssociationName } from '../types/dream.js';
 import { DefaultQueryTypeOptions, ExtendQueryType, NamespacedOrBaseModelColumnTypes, PaginatedDreamQueryOptions, PaginatedDreamQueryResult, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../types/query.js';
 import { JoinedAssociation, JoinedAssociationsTypeFromAssociations, QueryTypeOptions, VariadicJoinsArgs, VariadicLeftJoinLoadArgs, VariadicLoadArgs } from '../types/variadic.js';
 import DreamTransaction from './DreamTransaction.js';
-export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Readonly<QueryTypeOptions> = DefaultQueryTypeOptions<DreamInstance>> extends ConnectedToDB<DreamInstance> {
+import PostgresQueryDriver from './QueryDriver/Postgres.js';
+export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Readonly<QueryTypeOptions> = DefaultQueryTypeOptions<DreamInstance>> {
     /**
      * @internal
      *
@@ -182,6 +182,16 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * baseSelectQuery.
      */
     private baseSelectQuery;
+    private originalOpts;
+    protected readonly dreamClass: DreamConstructorType<DreamInstance>;
+    readonly dreamInstance: DreamInstance;
+    protected connectionOverride: DbConnectionType | undefined;
+    /**
+     * @internal
+     *
+     * stores the Dream models joined in this Query instance
+     */
+    protected readonly innerJoinDreamClasses: readonly (typeof Dream)[];
     constructor(dreamInstance: DreamInstance, opts?: QueryOpts<DreamInstance, DreamColumnNames<DreamInstance>>);
     /**
      * Returns true. Useful for distinguishing Query instances
@@ -190,14 +200,6 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * @returns true
      */
     get isDreamQuery(): boolean;
-    /**
-     * @internal
-     *
-     * Used for applying preload and load statements
-     *
-     * @returns An associated Query
-     */
-    private dreamClassQueryWithScopeBypasses;
     /**
      * @internal
      *
@@ -373,38 +375,6 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      *
      */
     private fleshOutJoinStatements;
-    /**
-     * @internal
-     *
-     *
-     */
-    private associationNamesToDreamClassesMap;
-    /**
-     * @internal
-     *
-     *
-     */
-    private associationNamesToAssociationsMap;
-    /**
-     * @internal
-     */
-    private associationNamesToAssociationDataAndDreamClassesMap;
-    /**
-     * @internal
-     */
-    private throughAssociationDetails;
-    /**
-     * @internal
-     *
-     *
-     */
-    private joinStatementsToDreamClassesMap;
-    /**
-     * @internal
-     *
-     *
-     */
-    private joinStatementsToAssociationsMap;
     /**
      * @internal
      *
@@ -718,21 +688,6 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      * @returns the min value of the specified column for this Query
      */
     min<Q extends Query<DreamInstance, QueryTypeOpts>, DB extends DreamInstance['DB'], ColumnName extends ColumnNamesAccountingForJoinedAssociations<Q['queryTypeOpts']['joinedAssociations'], DB, QueryTypeOpts['rootTableName'], QueryTypeOpts['rootTableAlias']>, ReturnType extends NamespacedOrBaseModelColumnTypes<[ColumnName], Q, DreamInstance>[0]>(columnName: ColumnName): Promise<ReturnType>;
-    /**
-     * @internal
-     *
-     * Runs the query and extracts plucked values
-     *
-     * @returns An array of plucked values
-     */
-    private executePluck;
-    /**
-     * @internal
-     *
-     */
-    private executeJoinLoad;
-    private fleshOutJoinLoadExecutionResults;
-    private hydratePreloadedThroughColumns;
     /**
      * Plucks the provided fields from the given dream class table
      *
@@ -787,6 +742,20 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
     all(options?: {
         columns?: DreamColumnNames<DreamInstance>[];
     }): Promise<DreamInstance[]>;
+    static dbDriverClass<T extends Dream>(): {
+        new (query: Query<T, any>): PostgresQueryDriver<T>;
+        migrate(): Promise<void>;
+        rollback(opts: {
+            steps: number;
+        }): Promise<void>;
+        generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
+        sync(onSync: () => Promise<void> | void): Promise<void>;
+        dbCreate(): Promise<void>;
+        dbDrop(): Promise<void>;
+        saveDream(dream: Dream, txn?: DreamTransaction<Dream> | null): Promise<any>;
+        duplicateDatabase(): Promise<void>;
+    };
+    dbDriverInstance(query?: Query<DreamInstance, any>): PostgresQueryDriver<DreamInstance>;
     /**
      * Paginates the results of your query, accepting a pageSize and page argument,
      * which it uses to segment your query into pages, leveraging limit and offset
@@ -1016,103 +985,6 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
         skipHooks?: boolean;
     }): Promise<number>;
     private updateWithoutCallingModelHooks;
-    /**
-     * @internal
-     *
-     * Used for applying first and last queries
-     *
-     * @returns A dream instance or null
-     */
-    private takeOne;
-    /**
-     * @internal
-     *
-     * Used to hydrate dreams with the provided associations
-     */
-    private hydrateAssociation;
-    /**
-     * @internal
-     *
-     * Used to bridge through associations
-     */
-    private followThroughAssociation;
-    /**
-     * @internal
-     *
-     * Polymorphic BelongsTo. Since polymorphic associations may point to multiple tables,
-     * preload by loading each target class separately.
-     *
-     * Used to preload polymorphic belongs to associations
-     */
-    private preloadPolymorphicBelongsTo;
-    private preloadPolymorphicAssociationModel;
-    /**
-     * @internal
-     *
-     * Applies a preload statement
-     */
-    private applyOnePreload;
-    /**
-     * @internal
-     *
-     * Used by loadBuider
-     */
-    private hydratePreload;
-    /**
-     * @internal
-     *
-     * Applies a preload statement
-     */
-    private applyPreload;
-    /**
-     * @internal
-     *
-     * retrieves on statements that can be applied to a preload
-     */
-    private applyablePreloadOnStatements;
-    private conditionallyApplyDefaultScopes;
-    /**
-     * Each association in the chain is pushed onto `throughAssociations`
-     * and `applyOneJoin` is recursively called. The trick is that the
-     * through associations don't get written into the SQL; they
-     * locate the next association we need to build into the SQL,
-     * which is only run by the association that started the `through`
-     * chain. The final association at the end of the `through` chain _is_
-     * written into the SQL as a full association, but the modifications from
-     * the `through` association are only added when the recursion returns
-     * back to the association that kicked off the through associations.
-     */
-    private joinsBridgeThroughAssociations;
-    private applyOneJoin;
-    private applyAssociationAndStatementsToJoinStatement;
-    private conditionallyApplyDefaultScopesDependentOnAssociation;
-    private distinctColumnNameForAssociation;
-    private recursivelyJoin;
-    private throwUnlessAllRequiredWhereClausesProvided;
-    private applyOrderStatementForAssociation;
-    private inArrayWithNull_or_notInArrayWithoutNull_ExpressionBuilder;
-    private inArrayWithoutNullExpressionBuilder;
-    private notInArrayWithNullExpressionBuilder;
-    private whereStatementToExpressionWrapper;
-    private dreamWhereStatementToExpressionBuilderParts;
-    private applyJoinAndStatement;
-    private _applyJoinAndStatements;
-    private _applyJoinAndAnyStatements;
-    private joinAndStatementToExpressionWrapper;
-    private buildCommon;
-    private checkForQueryViolations;
-    private aliasWhereStatements;
-    private aliasWhereStatement;
-    private rawifiedSelfOnClause;
-    private buildDelete;
-    private buildSelect;
-    private columnsWithRequiredLoadColumns;
-    private buildUpdate;
-    private attachLimitAndOrderStatementsToNonSelectQuery;
-    private get hasSimilarityClauses();
-    private similarityStatementBuilder;
-    private conditionallyAttachSimilarityColumnsToSelect;
-    private conditionallyAttachSimilarityColumnsToUpdate;
     private invertOrder;
 }
 export interface QueryOpts<DreamInstance extends Dream, ColumnType extends DreamColumnNames<DreamInstance> = DreamColumnNames<DreamInstance>, Schema extends DreamInstance['schema'] = DreamInstance['schema'], DB extends DreamInstance['DB'] = DreamInstance['DB'], PassthroughColumns extends PassthroughColumnNames<DreamInstance> = PassthroughColumnNames<DreamInstance>> {

package/dist/types/src/dream/QueryDriver/Base.d.ts

@@ -0,0 +1,242 @@
+import { DeleteQueryBuilder, SelectQueryBuilder, UpdateQueryBuilder } from 'kysely';
+import Dream from '../../Dream.js';
+import { AssociationStatement } from '../../types/associations/shared.js';
+import { DreamColumnNames, DreamConstructorType, DreamTableSchema } from '../../types/dream.js';
+import { PreloadedDreamsAndWhatTheyPointTo, QueryToKyselyDBType, QueryToKyselyTableNamesType } from '../../types/query.js';
+import DreamTransaction from '../DreamTransaction.js';
+import Query from '../Query.js';
+import PostgresQueryDriver from './Postgres.js';
+import { DbConnectionType } from '../../types/db.js';
+export default class QueryDriverBase<DreamInstance extends Dream> {
+    query: Query<DreamInstance, any>;
+    protected readonly dreamClass: DreamConstructorType<DreamInstance>;
+    protected readonly dreamInstance: DreamInstance;
+    protected dreamTransaction: DreamTransaction<Dream> | null;
+    protected connectionOverride: DbConnectionType | undefined;
+    /**
+     * @internal
+     *
+     * stores the Dream models joined in this Query instance
+     */
+    protected readonly innerJoinDreamClasses: readonly (typeof Dream)[];
+    constructor(query: Query<DreamInstance, any>);
+    /**
+     * migrate the database. Must respond to the NODE_ENV value.
+     */
+    static migrate(): Promise<void>;
+    /**
+     * rollback the database. Must respond to the NODE_ENV value.
+     */
+    static rollback(_: {
+        steps: number;
+    }): Promise<void>;
+    /**
+     * create the database. Must respond to the NODE_ENV value.
+     */
+    static dbCreate(): Promise<void>;
+    /**
+     * delete the database. Must respond to the NODE_ENV value.
+     */
+    static dbDrop(): Promise<void>;
+    /**
+     * This should build a new migration file in the migrations folder
+     * of your application. This will then need to be read and run
+     * whenever the `migrate` method is called. The filename should
+     * contain a timestamp at the front of the filename, so that it
+     * is sorted by date in the file tree, and, more importantly, so
+     * they can be run in order by your migration runner.
+     */
+    static generateMigration(migrationName: string, columnsWithTypes: string[]): Promise<void>;
+    /**
+     * defines the syncing behavior for dream and psychic,
+     * which is run whenever the `sync` command is called.
+     * This is an important step, and will be incredibly
+     * comlpex to override. You will need to do the following
+     * when overriding this method:
+     *
+     * 1. introspect the db and use it to generate a db.ts file in the
+     *    same shape as the existing one. Currently, the process for generating
+     *    this file is extremely complex and messy, and will be difficult
+     *    to achieve.
+     * 2. generate a types/dream.ts file in the same shape as the existing
+     *    one. This is normally done using `await new SchemaBuilder().build()`,
+     *    but this will likely need to be overridden to tailor to your custom
+     *    database engine.
+     */
+    static sync(_: () => Promise<void> | void): Promise<void>;
+    /**
+     * Converts the given dream class into a Kysely query, enabling
+     * you to build custom queries using the Kysely API
+     *
+     * ```ts
+     * await User.query().toKysely('select').where('email', '=', 'how@yadoin').execute()
+     * ```
+     *
+     * @param type - the type of Kysely query builder instance you would like to obtain
+     * @returns A Kysely query. Depending on the type passed, it will return either a SelectQueryBuilder, DeleteQueryBuilder, or an UpdateQueryBuilder
+     */
+    toKysely<QueryType extends 'select' | 'delete' | 'update', DbType = QueryToKyselyDBType<Query<DreamInstance>>, TableNames = QueryToKyselyTableNamesType<Query<DreamInstance>>, ToKyselyReturnType = QueryType extends 'select' ? SelectQueryBuilder<DbType, TableNames & keyof DbType, unknown> : QueryType extends 'delete' ? DeleteQueryBuilder<DbType, TableNames & keyof DbType, unknown> : QueryType extends 'update' ? UpdateQueryBuilder<DbType, TableNames & keyof DbType, TableNames & keyof DbType, unknown> : never>(type: QueryType): ToKyselyReturnType;
+    /**
+     * @internal
+     *
+     * This method is used internally by a Query driver to
+     * take the result of a single row in a database, and
+     * turn that row into the provided dream instance.
+     *
+     * If needed, the return type can be overriden to
+     * explicitly define the resulting dream instance,
+     * in cases where a proper type for the dream class
+     * cannot be inferred, i.e.
+     *
+     * ```ts
+     * this.dbResultToDreamInstance<typeof Dream, DreamInstance>(result, this.dreamClass)
+     * ```
+     */
+    dbResultToDreamInstance<DreamClass extends typeof Dream, RetType = InstanceType<DreamClass>>(result: any, dreamClass: typeof Dream): RetType;
+    /**
+     * @internal
+     *
+     * Used for applying first and last queries
+     *
+     * @returns A dream instance or null
+     */
+    takeOne(this: PostgresQueryDriver<DreamInstance>): Promise<DreamInstance | null>;
+    /**
+     * Retrieves an array containing all records matching the Query.
+     * Be careful using this, since it will attempt to pull every
+     * record into memory at once. When querying might return a large
+     * number of records, consider using `.findEach`, which will pull
+     * the records in batches.
+     *
+     * ```ts
+     * await User.query().all()
+     * ```
+     *
+     * @returns an array of dreams
+     */
+    takeAll(options?: {
+        columns?: DreamColumnNames<DreamInstance>[];
+    }): Promise<DreamInstance[]>;
+    /**
+     * Retrieves the max value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await User.query().max('id')
+     * // 99
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the max value of the specified column for this Query
+     *
+     */
+    max(columnName: string): Promise<any>;
+    /**
+     * Retrieves the min value of the specified column
+     * for this Query
+     *
+     * ```ts
+     * await User.query().min('id')
+     * // 1
+     * ```
+     *
+     * @param columnName - a column name on the model
+     * @returns the min value of the specified column for this Query
+     */
+    min(columnName: string): Promise<any>;
+    /**
+     * Retrieves the number of records in the database
+     *
+     * ```ts
+     * await User.query().count()
+     * ```
+     *
+     * @returns The number of records in the database
+     */
+    count(): Promise<number>;
+    /**
+     * @internal
+     *
+     * Runs the query and extracts plucked values
+     *
+     * @returns An array of plucked values
+     */
+    pluck(...fields: DreamColumnNames<DreamInstance>[]): Promise<any[]>;
+    /**
+     * Returns a new Kysely SelectQueryBuilder instance to be used
+     * in a sub Query
+     *
+     * ```ts
+     * const records = await User.where({
+     *   id: Post.query().nestedSelect('userId'),
+     * }).all()
+     * // [User{id: 1}, ...]
+     * ```
+     *
+     * @param selection - the column to use for your nested Query
+     * @returns A Kysely SelectQueryBuilder instance
+     */
+    nestedSelect<SimpleFieldType extends keyof DreamColumnNames<DreamInstance>, PluckThroughFieldType>(this: PostgresQueryDriver<DreamInstance>, selection: SimpleFieldType | PluckThroughFieldType): void;
+    /**
+     * executes provided query instance as a deletion query.
+     * @returns the number of deleted rows
+     */
+    delete(): Promise<number>;
+    /**
+     * executes provided query instance as an update query.
+     * @returns the number of updated rows
+     */
+    update(attributes: DreamTableSchema<DreamInstance>): Promise<number>;
+    /**
+     * persists any unsaved changes to the database. If a transaction
+     * is provided as a second argument, it will use that transaction
+     * to encapsulate the persisting of the dream, as well as any
+     * subsequent model hooks that are fired.
+     */
+    static saveDream(dream: Dream, txn?: DreamTransaction<Dream> | null): Promise<void>;
+    /**
+     * Returns the sql that would be executed by this Query
+     *
+     * ```ts
+     * User.where({ email: 'how@yadoin' }).sql()
+     * // {
+     * //  query: {
+     * //    kind: 'SelectQueryNode',
+     * //    from: { kind: 'FromNode', froms: [Array] },
+     * //    selections: [ [Object] ],
+     * //    distinctOn: undefined,
+     * //    joins: undefined,
+     * //    groupBy: undefined,
+     * //    orderBy: undefined,
+     * //    where: { kind: 'WhereNode', where: [Object] },
+     * //    frontModifiers: undefined,
+     * //    endModifiers: undefined,
+     * //    limit: undefined,
+     * //    offset: undefined,
+     * //    with: undefined,
+     * //    having: undefined,
+     * //    explain: undefined,
+     * //    setOperations: undefined
+     * //  },
+     * //  sql: 'select "users".* from "users" where ("users"."email" = $1 and "users"."deleted_at" is null)',
+     * //  parameters: [ 'how@yadoin' ]
+     * //}
+     * ```
+     *
+     * @returns An object representing the underlying sql statement
+     *
+     */
+    sql(): void;
+    /**
+     * @internal
+     *
+     * Used to hydrate dreams with the provided associations
+     */
+    hydrateAssociation(dreams: Dream[], association: AssociationStatement, preloadedDreamsAndWhatTheyPointTo: PreloadedDreamsAndWhatTheyPointTo[]): void;
+    /**
+     * @internal
+     *
+     * Used by loadBuider
+     */
+    hydratePreload(this: QueryDriverBase<DreamInstance>, dream: Dream): Promise<void>;
+}