@rvoh/dream 0.29.1

package/dist/cjs/src/dream/internal/similarity/SimilarityBuilder.js

@@ -0,0 +1,331 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SIMILARITY_TYPES = void 0;
+const kysely_1 = require("kysely");
+const ConnectedToDB_js_1 = require("../../../db/ConnectedToDB.js");
+const validateColumn_js_1 = require("../../../db/validators/validateColumn.js");
+const validateTable_js_1 = require("../../../db/validators/validateTable.js");
+const validateTableAlias_js_1 = require("../../../db/validators/validateTableAlias.js");
+const namespaceColumn_js_1 = require("../../../helpers/namespaceColumn.js");
+const typechecks_js_1 = require("../../../helpers/typechecks.js");
+const types_js_1 = require("../../types.js");
+const similaritySelectSql_js_1 = require("./similaritySelectSql.js");
+const similarityWhereSql_js_1 = require("./similarityWhereSql.js");
+class SimilarityBuilder extends ConnectedToDB_js_1.default {
+    whereStatement;
+    whereNotStatement;
+    joinOnStatements = Object.freeze({});
+    constructor(dreamInstance, opts = {}) {
+        super(dreamInstance, opts);
+        this.whereStatement = Object.freeze(opts.where || []);
+        this.whereNotStatement = Object.freeze(opts.whereNot || []);
+        this.joinOnStatements = Object.freeze(opts.joinOnStatements || {});
+    }
+    /*
+    #select
+  
+    uses ts_vector, ts_rank, and similarity/wordSimilarity/strictWordSimilarity to add to an existing select query
+  
+    produces the following sql:
+    select
+      "users".*
+    from
+      "users"
+      inner join (
+        select
+          "users"."id" as "trigram_search_id",
+          (
+            ts_rank(
+              (
+                to_tsvector(
+                  'simple',
+                  coalesce("users"."name" :: text, '')
+                )
+              ),
+              (websearch_to_tsquery('simple', ''' ' || $ 1 :: text || ' ''')),
+              0
+            )
+          ) as "where_rank_1"
+        from
+          "users"
+        where
+          (
+            similarity(
+              $ 2 :: text,
+              (coalesce("users"."name" :: text, ''))
+            ) < $ 3
+          )
+      ) as "trigram_search_9f213a82d057f3547e51872ca4f04f29d141565c" on "users"."id" = "trigram_search_9f213a82d057f3547e51872ca4f04f29d141565c"."trigram_search_id"
+    where
+      "users"."deleted_at" is null
+    order by
+      "trigram_search_9f213a82d057f3547e51872ca4f04f29d141565c"."where_rank_1" desc
+  
+    [ world, world, 0.5 ]
+    */
+    select(kyselyQuery, { bypassOrder = false } = {}) {
+        this.whereStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
+            kyselyQuery = this.addStatementToSelectQuery({
+                kyselyQuery,
+                similarityStatement,
+                statementType: 'where',
+                index,
+                bypassOrder,
+            });
+        });
+        this.joinOnStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
+            kyselyQuery = this.addStatementToSelectQuery({
+                kyselyQuery,
+                similarityStatement,
+                statementType: 'on',
+                index,
+                bypassOrder,
+            });
+        });
+        return kyselyQuery;
+    }
+    /*
+    #update
+  
+    uses ts_vector, ts_rank, and similarity/wordSimilarity/strictWordSimilarity to add to an existing update query
+  
+    update
+      "compositions"
+    set
+      "content" = $ 1
+    where
+      "id" in (
+        select
+          "trigram_search_5a2aaab94c01acc649c87561240264e9a0ab7ecb"."trigram_search_id"
+        from
+          "compositions"
+          inner join (
+            select
+              "compositions"."id" as "trigram_search_id",
+              "id",
+              (
+                ts_rank(
+                  (
+                    to_tsvector(
+                      'simple',
+                      coalesce("compositions"."content" :: text, '')
+                    )
+                  ),
+                  (websearch_to_tsquery('simple', ''' ' || $ 2 :: text || ' ''')),
+                  0
+                )
+              ) as "where_rank_1"
+            from
+              "compositions"
+            where
+              (
+                similarity(
+                  $ 3 :: text,
+                  (coalesce("compositions"."content" :: text, ''))
+                ) >= $ 4
+              )
+          ) as "trigram_search_5a2aaab94c01acc649c87561240264e9a0ab7ecb" on "compositions"."id" = "trigram_search_5a2aaab94c01acc649c87561240264e9a0ab7ecb"."trigram_search_id"
+      )
+      and "compositions"."id" in (
+        select
+          "compositions"."id"
+        from
+          "users"
+          inner join "compositions" on "users"."id" = "compositions"."user_id"
+        where
+          "users"."id" = $ 5
+          and "users"."deleted_at" is null
+      )
+  
+    [ cool, Opus, Opus, 0.3, 8818 ]
+    */
+    update(kyselyQuery) {
+        this.whereStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
+            kyselyQuery = this.addStatementToUpdateQuery({
+                kyselyQuery,
+                similarityStatement,
+                statementType: 'where',
+                index,
+            });
+        });
+        this.joinOnStatementsWithSimilarityClauses().forEach((similarityStatement, index) => {
+            kyselyQuery = this.addStatementToUpdateQuery({
+                kyselyQuery,
+                similarityStatement,
+                statementType: 'on',
+                index,
+            });
+        });
+        return kyselyQuery;
+    }
+    get hasSimilarityClauses() {
+        return !!this.statementsWithSimilarityClauses().length;
+    }
+    whereStatementsWithSimilarityClauses() {
+        return this.similarityStatementFilter(this.whereStatement);
+    }
+    whereNotStatementsWithSimilarityClauses() {
+        return this.similarityStatementFilter(this.whereNotStatement);
+    }
+    joinOnStatementsWithSimilarityClauses() {
+        return this.recursiveJoinsOnFinder(removeOnFromObjectHierarchy(this.joinOnStatements), this.dreamClass);
+    }
+    recursiveJoinsOnFinder(obj, dreamClass) {
+        const similar = [];
+        Object.keys(obj).forEach(associationName => {
+            const tableValues = obj[associationName];
+            const associationMetadata = dreamClass['associationMetadataMap']()[associationName];
+            if (!associationMetadata) {
+                return;
+            }
+            let associationDreamClass = associationMetadata.modelCB();
+            if (Array.isArray(associationDreamClass))
+                associationDreamClass = associationDreamClass[0];
+            const tableName = associationDreamClass.table;
+            Object.keys(tableValues).forEach(columnOrAssociationName => {
+                const statementOrValueOrNestedObject = tableValues[columnOrAssociationName];
+                if (statementOrValueOrNestedObject?.isOpsStatement &&
+                    types_js_1.TRIGRAM_OPERATORS.includes(statementOrValueOrNestedObject?.operator)) {
+                    similar.push({
+                        tableName,
+                        tableAlias: associationName,
+                        columnName: columnOrAssociationName,
+                        opsStatement: statementOrValueOrNestedObject,
+                    });
+                }
+                else if ((0, typechecks_js_1.isObject)(statementOrValueOrNestedObject) &&
+                    !statementOrValueOrNestedObject?.isOpsStatement) {
+                    // if it is an object, but not an array, it is likely a nested joins statement,
+                    // since joinsWhere objects can take a recursive shape, like:
+                    // {
+                    //   users: { compositions: { compositionAssets: { compositionAssetAudits: { notes: [OpsStatement] } } } }
+                    // }
+                    similar.push(...this.recursiveJoinsOnFinder(tableValues, associationDreamClass));
+                }
+            });
+        });
+        return similar;
+    }
+    statementsWithSimilarityClauses() {
+        return [
+            ...this.whereStatementsWithSimilarityClauses(),
+            ...this.whereNotStatementsWithSimilarityClauses(),
+            ...this.joinOnStatementsWithSimilarityClauses(),
+        ];
+    }
+    addStatementToSelectQuery({ kyselyQuery, similarityStatement, index, statementType, bypassOrder, }) {
+        const schema = this.dreamClass.prototype.schema;
+        const primaryKeyName = this.dreamClass.primaryKey;
+        const { tableName, tableAlias, columnName } = similarityStatement;
+        // eslint-disable-next-line @typescript-eslint/unbound-method
+        const { ref } = this.dbFor('select').dynamic;
+        const validatedTableAlias = (0, validateTableAlias_js_1.default)(tableAlias);
+        const validatedPrimaryKey = (0, validateColumn_js_1.default)(schema, tableName, primaryKeyName);
+        const nestedQuery = this.buildNestedSelectQuery({
+            primaryKeyName,
+            similarityStatement,
+            statementIndex: index,
+            statementType,
+        });
+        const trigramSearchAlias = this.similaritySearchId(tableAlias, columnName);
+        kyselyQuery = kyselyQuery.innerJoin(nestedQuery.as(trigramSearchAlias), join => join.onRef((0, namespaceColumn_js_1.default)(validatedPrimaryKey, validatedTableAlias), '=', (0, namespaceColumn_js_1.default)('trigram_search_id', trigramSearchAlias)));
+        if (!bypassOrder) {
+            const rankSQLAlias = this.rankSQLAlias(statementType, index);
+            kyselyQuery = kyselyQuery.orderBy(ref((0, namespaceColumn_js_1.default)(rankSQLAlias, trigramSearchAlias)), 'desc');
+        }
+        return kyselyQuery;
+    }
+    addStatementToUpdateQuery({ kyselyQuery, similarityStatement, statementType, index, }) {
+        const { tableName, tableAlias, columnName } = similarityStatement;
+        const schema = this.dreamClass.prototype.schema;
+        const primaryKeyName = this.dreamClass.primaryKey;
+        const validatedTableAlias = (0, validateTableAlias_js_1.default)(tableAlias);
+        const validatedPrimaryKey = (0, validateColumn_js_1.default)(schema, tableName, primaryKeyName);
+        const nestedQuery = this.buildNestedSelectQuery({
+            primaryKeyName: validatedPrimaryKey,
+            similarityStatement,
+            statementIndex: index,
+            statementType,
+        });
+        const trigramSearchAlias = this.similaritySearchId(tableAlias, columnName);
+        const selectQuery = this.dbFor('select')
+            .selectFrom(validatedTableAlias)
+            .select(`${trigramSearchAlias}.trigram_search_id`)
+            .innerJoin(nestedQuery.as(trigramSearchAlias), join => join.onRef((0, namespaceColumn_js_1.default)(validatedPrimaryKey, validatedTableAlias), '=', (0, namespaceColumn_js_1.default)('trigram_search_id', trigramSearchAlias)));
+        kyselyQuery = kyselyQuery.where(primaryKeyName, 'in', selectQuery);
+        return kyselyQuery;
+    }
+    buildNestedSelectQuery({ primaryKeyName, statementType, statementIndex, similarityStatement, }) {
+        const schema = this.dreamClass.prototype.schema;
+        const { columnName, opsStatement, tableName } = similarityStatement;
+        const validatedTable = (0, validateTable_js_1.default)(schema, tableName);
+        const validatedPrimaryKey = (0, validateColumn_js_1.default)(schema, tableName, primaryKeyName);
+        let nestedQuery = this.dbFor('select')
+            .selectFrom(tableName)
+            .select(eb => {
+            const tableNameRef = eb.ref(validatedTable);
+            const columnRef = eb.ref(validatedPrimaryKey);
+            return (0, kysely_1.sql) `${tableNameRef}.${columnRef}`.as('trigram_search_id');
+        });
+        const rankSQLAlias = this.rankSQLAlias(statementType, statementIndex);
+        nestedQuery = nestedQuery
+            .select(eb => (0, similaritySelectSql_js_1.default)({
+            eb,
+            tableName,
+            columnName,
+            opsStatement,
+            schema,
+            rankSQLAlias,
+        }))
+            .where(eb => (0, similarityWhereSql_js_1.default)({
+            eb,
+            tableName,
+            columnName,
+            opsStatement,
+            schema,
+        }));
+        return nestedQuery;
+    }
+    similarityStatementFilter(statements) {
+        const similar = [];
+        const tableName = this.dreamClass.table;
+        statements.forEach(statement => {
+            Object.keys(statement).forEach(key => {
+                if (statement[key]?.constructor?.name === 'OpsStatement' &&
+                    types_js_1.TRIGRAM_OPERATORS.includes(statement[key].operator)) {
+                    similar.push({
+                        tableName,
+                        tableAlias: tableName,
+                        columnName: key,
+                        opsStatement: statement[key],
+                    });
+                }
+            });
+        });
+        return similar;
+    }
+    similaritySearchId(tableName, columnName) {
+        return `trigram_search_${tableName}_${columnName}`;
+    }
+    rankSQLAlias(statementType, statementIndex) {
+        return `${statementType}_rank_${statementIndex + 1}`;
+    }
+}
+exports.default = SimilarityBuilder;
+exports.SIMILARITY_TYPES = ['where', 'on'];
+function removeOnFromObjectHierarchy(obj) {
+    if (obj?.isOpsStatement)
+        return obj;
+    const result = {};
+    for (const key in obj) {
+        if (Object.prototype.hasOwnProperty.call(obj, key)) {
+            if ((0, typechecks_js_1.isObject)(obj[key])) {
+                result[key] = removeOnFromObjectHierarchy(obj[key].on || obj[key]);
+            }
+            else {
+                result[key] = obj[key];
+            }
+        }
+    }
+    return result;
+}

package/dist/cjs/src/dream/internal/similarity/similaritySelectSql.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = similaritySelectSql;
+const kysely_1 = require("kysely");
+const validateColumn_js_1 = require("../../../db/validators/validateColumn.js");
+const validateTable_js_1 = require("../../../db/validators/validateTable.js");
+function similaritySelectSql({ eb, tableName, columnName, opsStatement, schema, rankSQLAlias, }) {
+    return (0, kysely_1.sql) `
+  (
+    ts_rank(
+      (
+        to_tsvector(
+          'simple',
+          coalesce(${eb.ref((0, validateTable_js_1.default)(schema, tableName))}.${eb.ref((0, validateColumn_js_1.default)(schema, tableName, columnName))} :: text, '')
+        )
+      ),
+      (websearch_to_tsquery('simple', ''' ' || ${opsStatement.value}::text || ' ''')),
+      0
+    )
+  )`.as(eb.ref(rankSQLAlias));
+}

package/dist/cjs/src/dream/internal/similarity/similarityWhereSql.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = similarityWhereSql;
+const kysely_1 = require("kysely");
+const validateColumn_js_1 = require("../../../db/validators/validateColumn.js");
+const validateTable_js_1 = require("../../../db/validators/validateTable.js");
+function similarityWhereSql({ eb, tableName, columnName, opsStatement, schema, }) {
+    let functionName = 'similarity';
+    switch (opsStatement.operator) {
+        case '<%':
+            functionName = 'word_similarity';
+            break;
+        case '<<%':
+            functionName = 'strict_word_similarity';
+            break;
+    }
+    return (0, kysely_1.sql) `(${kysely_1.sql.raw(functionName)}(
+      ${opsStatement.value}::text,
+      (coalesce(${eb.ref((0, validateTable_js_1.default)(schema, tableName))}.${eb.ref((0, validateColumn_js_1.default)(schema, tableName, columnName))} :: text, ''))
+    ) >= ${opsStatement.minTrigramScore})`;
+}

package/dist/cjs/src/dream/internal/softDeleteDream.js

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = softDeleteDream;
+const luxon_1 = require("luxon");
+const MissingDeletedAtFieldForSoftDelete_js_1 = require("../../errors/MissingDeletedAtFieldForSoftDelete.js");
+const isDateTimeColumn_js_1 = require("../../helpers/db/types/isDateTimeColumn.js");
+async function softDeleteDream(dream, txn) {
+    const deletedAtField = dream.deletedAtField;
+    const dreamClass = dream.constructor;
+    if (!(0, isDateTimeColumn_js_1.default)(dreamClass, deletedAtField)) {
+        throw new MissingDeletedAtFieldForSoftDelete_js_1.default(dream.constructor);
+    }
+    let query = txn.kyselyTransaction
+        .updateTable(dream.table)
+        .where(dream.primaryKey, '=', dream.primaryKeyValue)
+        .set(dream.deletedAtField, luxon_1.DateTime.now());
+    dreamClass['sortableFields']?.forEach(sortableFieldMetadata => {
+        const positionColumn = sortableFieldMetadata.positionField;
+        query = query.set(positionColumn, null);
+    });
+    await query.execute();
+}

package/dist/cjs/src/dream/internal/sqlResultToDreamInstance.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = sqlResultToDreamInstance;
+exports.findExtendingDreamClass = findExtendingDreamClass;
+const STIChildMissing_js_1 = require("../../errors/sti/STIChildMissing.js");
+function sqlResultToDreamInstance(dreamClass, sqlResult) {
+    if (dreamClass['isSTIBase']) {
+        const extendingDreamClass = findExtendingDreamClass(dreamClass, sqlResult.type);
+        if (!extendingDreamClass)
+            throw new STIChildMissing_js_1.default(dreamClass, sqlResult.type, sqlResult[dreamClass.primaryKey]);
+        const dreamModel = new extendingDreamClass(sqlResult, {
+            bypassUserDefinedSetters: true,
+            isPersisted: true,
+            _internalUseOnly: true,
+        });
+        dreamModel['finalizeConstruction']();
+        return dreamModel;
+    }
+    else {
+        const dreamModel = new dreamClass(sqlResult, {
+            bypassUserDefinedSetters: true,
+            isPersisted: true,
+            _internalUseOnly: true,
+        });
+        dreamModel['finalizeConstruction']();
+        return dreamModel;
+    }
+}
+function findExtendingDreamClass(dreamClass, type) {
+    if (!dreamClass['extendedBy'])
+        return undefined;
+    const extendingDreamClass = dreamClass['extendedBy'].find(extendingDreamClass => extendingDreamClass.name === type);
+    if (extendingDreamClass)
+        return extendingDreamClass;
+    return dreamClass['extendedBy']
+        .map(extendingDreamClass => findExtendingDreamClass(extendingDreamClass, type))
+        .find(dreamClassOrUndefined => dreamClassOrUndefined);
+}

package/dist/cjs/src/dream/internal/undestroyDream.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = undestroyDream;
+const setPosition_js_1 = require("../../decorators/sortable/helpers/setPosition.js");
+const runHooksFor_js_1 = require("./runHooksFor.js");
+const safelyRunCommitHooks_js_1 = require("./safelyRunCommitHooks.js");
+/**
+ * @internal
+ *
+ * Destroys the Dream and any `dependent: 'destroy'` associations
+ * within a transaction. If a transaction is passed, it will be used.
+ * Otherwise, a new transaction will be created automatically.
+ * If any of the nested associations fails to destroy, then this
+ * record will also fail to destroy. If skipHooks is true, model hooks
+ * will be bypassed.
+ */
+async function undestroyDream(dream, txn = null, options) {
+    if (txn) {
+        return await undestroyDreamWithTransaction(dream, txn, options);
+    }
+    else {
+        const dreamClass = dream.constructor;
+        return await dreamClass.transaction(async (txn) => await undestroyDreamWithTransaction(dream, txn, options));
+    }
+}
+/**
+ * @internal
+ *
+ * Given a transaction, applies the destroy query,
+ * including cascading to child associations and
+ * model hooks.
+ */
+async function undestroyDreamWithTransaction(dream, txn, options) {
+    const { cascade, skipHooks } = options;
+    if (!skipHooks) {
+        await (0, runHooksFor_js_1.default)('beforeUpdate', dream, true, null, txn);
+    }
+    await doUndestroyDream(dream, txn);
+    if (cascade) {
+        await undestroyAssociatedRecords(dream, txn, options);
+    }
+    if (!skipHooks) {
+        await (0, runHooksFor_js_1.default)('afterUpdate', dream, true, null, txn);
+        await (0, safelyRunCommitHooks_js_1.default)(dream, 'afterUpdateCommit', true, null, txn);
+    }
+    await dream.txn(txn).reload();
+    return dream;
+}
+/**
+ * @internal
+ *
+ * Destroys the dream iff it was not blocked from
+ * deleting by one of the beforeDestroy model hooks
+ */
+async function doUndestroyDream(dream, txn) {
+    let query = txn.kyselyTransaction
+        .updateTable(dream.table)
+        .where(dream.primaryKey, '=', dream.primaryKeyValue)
+        .set({ [dream.deletedAtField]: null });
+    const dreamClass = dream.constructor;
+    dreamClass['sortableFields']?.forEach(sortableFieldMetadata => {
+        const positionColumn = sortableFieldMetadata.positionField;
+        query = query.set(eb => ({
+            [positionColumn]: eb((0, setPosition_js_1.applySortableScopesToQuery)(dream, txn.kyselyTransaction.selectFrom(dream.table), column => dream[column], sortableFieldMetadata.scope).select(eb => eb.fn.max(positionColumn).as(positionColumn + '_max')), '+', 1),
+        }));
+    });
+    return await query.execute();
+}
+/**
+ * @internal
+ *
+ * Destroys all HasOne/HasMany associations on this
+ * dream that are marked as `dependent: 'destroy'`
+ */
+async function undestroyAssociatedRecords(dream, txn, options) {
+    const dreamClass = dream.constructor;
+    for (const associationName of dreamClass['dependentDestroyAssociationNames']()) {
+        const associationMetadata = dreamClass['associationMetadataMap']()[associationName];
+        const associatedClass = associationMetadata?.modelCB?.();
+        if (Array.isArray(associatedClass)) {
+            // TODO: decide how to handle polymorphic associations with dependent: destroy
+            // raise?
+        }
+        else {
+            if (associatedClass?.['softDelete']) {
+                await dream.txn(txn).undestroyAssociation(associationName, options);
+            }
+        }
+    }
+}

package/dist/cjs/src/dream/types.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRIGRAM_OPERATORS = exports.DreamConst = exports.primaryKeyTypes = void 0;
+exports.primaryKeyTypes = ['bigserial', 'bigint', 'uuid', 'integer'];
+class RequiredAttribute {
+    constructor() { }
+}
+class PassthroughAttribute {
+    constructor() { }
+}
+exports.DreamConst = {
+    passthrough: PassthroughAttribute,
+    required: RequiredAttribute,
+};
+exports.TRIGRAM_OPERATORS = ['%', '<%', '<<%'];
+// export type LeftJoinedPreloadAssociationsTypeFromAssociations<
+//   DB,
+//   Schema,
+//   ConcreteTableName extends keyof Schema & AssociationTableNames<DB, Schema> & keyof DB,
+//   ConcreteArgs extends readonly Readonly<unknown[]>,
+//   Depth extends number = 0,
+//   //
+//   //
+//   PreviousConcreteTableName = ConcreteTableName,
+//   ConcreteAssociationName = never,
+//   //
+//   JoinedAssociationsType extends Readonly<JoinedAssociation[]> = Readonly<[]>,
+//   SchemaAssociations = Schema[ConcreteTableName]['associations' & keyof Schema[ConcreteTableName]],
+//   //
+//   ConcreteNthArg extends
+//     | (keyof SchemaAssociations & string)
+//     | AliasedSchemaAssociation<Schema, ConcreteTableName>
+//     | Readonly<((keyof SchemaAssociations & string) | AliasedSchemaAssociation<Schema, ConcreteTableName>)[]>
+//     | null = ConcreteArgs[0] extends undefined
+//     ? null
+//     : ConcreteArgs[0] extends null
+//     ? null
+//     : ConcreteArgs[0] extends keyof SchemaAssociations & string
+//       ? ConcreteArgs[0] & keyof SchemaAssociations & string
+//       : ConcreteArgs[0] extends AliasedSchemaAssociation<Schema, ConcreteTableName>
+//         ? ConcreteArgs[0] & AliasedSchemaAssociation<Schema, ConcreteTableName>
+//         : null,
+//   //
+//   //
+//   CurrentArgumentType extends
+//     | IS_ASSOCIATION_NAME
+//     | IS_ASSOCIATION_ALIAS
+//     | IS_NOT_ASSOCIATION_NAME = ConcreteNthArg extends null
+//     ? IS_NOT_ASSOCIATION_NAME
+//     : ConcreteNthArg extends keyof SchemaAssociations & string
+//       ? IS_ASSOCIATION_NAME
+//       : ConcreteNthArg extends AliasedSchemaAssociation<Schema, ConcreteTableName>
+//         ? IS_ASSOCIATION_ALIAS
+//         : IS_NOT_ASSOCIATION_NAME,
+//   //
+//   NextUnaliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME
+//     ? ConcreteNthArg
+//     : CurrentArgumentType extends IS_ASSOCIATION_ALIAS
+//       ? ConcreteNthArg extends `${infer AssocName extends string} as ${string}`
+//         ? AssocName & keyof SchemaAssociations
+//         : never
+//       : never,
+//   //
+//   NextAliasedAssociationName = CurrentArgumentType extends IS_ASSOCIATION_NAME
+//     ? ConcreteNthArg
+//     : CurrentArgumentType extends IS_ASSOCIATION_ALIAS
+//       ? ConcreteNthArg extends `${string} as ${infer Alias extends string}`
+//         ? Alias
+//         : ConcreteAssociationName
+//       : ConcreteAssociationName,
+//   //
+//   NextTableName extends keyof Schema &
+//     AssociationTableNames<DB, Schema> &
+//     keyof DB = CurrentArgumentType extends IS_ASSOCIATION_NAME
+//     ? AssociationTableName<Schema, ConcreteTableName, NextUnaliasedAssociationName>
+//     : CurrentArgumentType extends IS_ASSOCIATION_ALIAS
+//     ? AssociationTableName<Schema, ConcreteTableName, NextUnaliasedAssociationName>
+//       : ConcreteTableName & AssociationTableNames<DB, Schema> & keyof DB,
+//   //
+// > = ConcreteArgs['length'] extends 0
+//   ? JoinedAssociationsType
+//   : Depth extends MAX_VARIADIC_DEPTH
+//     ? never
+//     : LeftJoinedPreloadAssociationsTypeFromAssociations<
+//         DB,
+//         Schema,
+//         ConcreteTableName,
+//         ReadonlyTail<ConcreteArgs>,
+//         Inc<Depth>,
+//         PreviousConcreteTableName,
+//         ConcreteAssociationName,
+//         Readonly<
+//           [
+//             ...JoinedAssociationsType,
+//             { table: NextTableName & string; alias: NextAliasedAssociationName & string },
+//           ]
+//         >
+//       >

package/dist/cjs/src/dream-application/cache.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cacheDreamApplication = cacheDreamApplication;
+exports.getCachedDreamApplicationOrFail = getCachedDreamApplicationOrFail;
+let _dreamApp = undefined;
+function cacheDreamApplication(dreamconf) {
+    _dreamApp = dreamconf;
+}
+function getCachedDreamApplicationOrFail() {
+    if (!_dreamApp)
+        throw new Error('must call `cacheDreamconf` before loading cached dreamconf');
+    return _dreamApp;
+}