@rvoh/dream 0.29.4 → 0.29.6

package/dist/cjs/src/db/DreamDbConnection.js

@@ -2,10 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.dreamDbConnections = dreamDbConnections;
 exports.closeAllDbConnections = closeAllDbConnections;
-const kysely_1 = require("kysely");
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 const pg_1 = require("pg");
+const kysely_1 = require("kysely");
 const index_js_1 = require("../dream-application/index.js");
 const ConnectionConfRetriever_js_1 = require("./ConnectionConfRetriever.js");
 let connections = {};

package/dist/cjs/src/db/errors.js

@@ -2,8 +2,15 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PG_ERRORS = void 0;
 exports.pgErrorType = pgErrorType;
-const pg = require("pg");
-const { DatabaseError } = pg;
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+const pg_1 = require("pg");
 exports.PG_ERRORS = {
     23505: 'UNIQUE_CONSTRAINT_VIOLATION',
 };
@@ -11,7 +18,7 @@ function pgErrorFromCode(code) {
     return exports.PG_ERRORS[code] || null;
 }
 function pgErrorType(error) {
-    if (error instanceof DatabaseError)
+    if (error instanceof pg_1.default.DatabaseError)
         return pgErrorFromCode(error.code);
     return null;
 }

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

@@ -1101,6 +1101,9 @@ class Query extends ConnectedToDB_js_1.default {
             // base model, it will be underscored (to match the table name), but when the selected column
             // comes back from Kysely camelCased
             aliases.push(field.includes('_') ? (0, camelize_js_1.default)(field) : field);
+            //  namespace the selection so that when plucking the same column name from
+            // multpile tables, they don't get saved as the same name (e.g. select results with two `id` columns,
+            // which the pg package then returns in an object with a single `id` key)
             kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(field)} as ${field}`);
         });
         return (await (0, executeDatabaseQuery_js_1.default)(kyselyQuery, 'execute')).map(singleResult => aliases.map(alias => singleResult[alias]));
@@ -1802,14 +1805,15 @@ class Query extends ConnectedToDB_js_1.default {
         const dream = dreams.find(dream => dream['getAssociationMetadata'](associationName));
         if (!dream)
             return;
-        const association = dream['getAssociationMetadata'](associationName);
+        const { name, alias } = (0, extractAssociationMetadataFromAssociationName_js_1.default)(associationName);
+        const association = dream['getAssociationMetadata'](name);
         const dreamClass = dream.constructor;
         const dreamClassToHydrate = association.modelCB();
         if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
             return this.preloadPolymorphicBelongsTo(association, dreams);
         const dreamClassToHydrateColumns = [...dreamClassToHydrate.columns()];
         const throughColumnsToHydrate = [];
-        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), associationName));
+        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), alias));
         const asHasAssociation = association;
         if (asHasAssociation.through && asHasAssociation.preloadThroughColumns) {
             if ((0, typechecks_js_1.isObject)(asHasAssociation.preloadThroughColumns)) {
@@ -1921,9 +1925,17 @@ class Query extends ConnectedToDB_js_1.default {
         }
         return query;
     }
-    // Through associations don't get written into the SQL; they
-    // locate the next association we need to build into the SQL
-    // AND the source to reference on the other side
+    /**
+     * 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.
+     */
     joinsBridgeThroughAssociations({ query, dreamClass, association, previousAssociationTableOrAlias, throughAssociations, joinType, }) {
         if (association.type === 'BelongsTo' || !association.through) {
             return {
@@ -2004,25 +2016,33 @@ class Query extends ConnectedToDB_js_1.default {
         previousAssociationTableOrAlias = results.previousAssociationTableOrAlias;
         const throughClass = results.throughClass;
         if (timeToApplyThroughAssociations) {
-            ///////////////////////////////////////////////////////////////////////////////////////
-            // when an association is through another association, `joinsBridgeThroughAssociations`
-            // is called, which eventually calls back to this method, passing in the original
-            // through association as `originalAssociation`
-            ///////////////////////////////////////////////////////////////////////////////////////
+            /**
+             * 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 (thus the
+             * `throughAssociations.length && throughAssociations[0].source === association.as`
+             * above). 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.
+             */
             throughAssociations.forEach((throughAssociation) => {
                 if (throughAssociation.type === 'HasMany') {
                     if (query?.distinctOn && throughAssociation.distinct) {
                         query = query.distinctOn(this.distinctColumnNameForAssociation({
                             association: throughAssociation,
-                            tableNameOrAlias: throughAssociation.as,
+                            tableNameOrAlias: currentAssociationTableOrAlias,
                             foreignKey: throughAssociation.primaryKey(),
                         }));
                     }
                     if (throughAssociation.order) {
                         query = this.applyOrderStatementForAssociation({
                             query,
-                            tableNameOrAlias: throughAssociation.as,
                             association: throughAssociation,
+                            tableNameOrAlias: currentAssociationTableOrAlias,
                         });
                     }
                 }

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

@@ -1,5 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 const pg_1 = require("pg");

package/dist/cjs/src/helpers/db/loadPgClient.js

@@ -1,6 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.default = loadPgClient;
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 const pg_1 = require("pg");

package/dist/cjs/src/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.range = exports.Range = exports.sharedPathPrefix = exports.relativeDreamPath = exports.dreamPath = exports.pascalize = exports.loadRepl = exports.isEmpty = exports.inferSerializerFromDreamOrViewModel = exports.inferSerializerFromDreamClassOrViewModelClass = exports.hyphenize = exports.globalClassNameFromFullyQualifiedModelName = exports.Env = exports.debug = exports.compact = exports.generateDream = exports.capitalize = exports.camelize = exports.CalendarDate = exports.Benchmark = exports.ValidationError = exports.RecordNotFound = exports.GlobalNameNotSet = exports.CreateOrFindByFailedToCreateAndFind = exports.NonLoadedAssociation = exports.Encrypt = exports.DreamConst = exports.Query = exports.DreamTransaction = exports.Dream = exports.DreamApplication = exports.lookupClassByGlobalName = exports.DreamImporter = exports.Virtual = exports.Validates = exports.Validate = exports.STI = exports.SoftDelete = exports.Scope = exports.ReplicaSafe = exports.Decorators = exports.validateTable = exports.validateColumn = exports.DreamMigrationHelpers = exports.db = exports.pgErrorType = exports.dreamDbConnections = exports.closeAllDbConnections = exports.DreamCLI = exports.DreamBin = void 0;
-exports.DreamSerializer = exports.Attribute = exports.RendersOne = exports.RendersMany = exports.ops = exports.openapiShorthandPrimitiveTypes = exports.openapiPrimitiveTypes = exports.uniq = exports.uncapitalize = exports.standardizeFullyQualifiedModelName = exports.sortBy = exports.snakeify = exports.serializerNameFromFullyQualifiedModelName = exports.round = void 0;
+exports.Range = exports.sharedPathPrefix = exports.relativeDreamPath = exports.dreamPath = exports.pascalize = exports.loadRepl = exports.isEmpty = exports.inferSerializerFromDreamOrViewModel = exports.inferSerializerFromDreamClassOrViewModelClass = exports.hyphenize = exports.globalClassNameFromFullyQualifiedModelName = exports.Env = exports.debug = exports.compact = exports.generateDream = exports.capitalize = exports.camelize = exports.CalendarDate = exports.Benchmark = exports.ValidationError = exports.RecordNotFound = exports.GlobalNameNotSet = exports.CreateOrFindByFailedToCreateAndFind = exports.NonLoadedAssociation = exports.Encrypt = exports.DreamConst = exports.Query = exports.DreamTransaction = exports.Dream = exports.DreamApplication = exports.lookupClassByGlobalName = exports.DreamImporter = exports.Virtual = exports.Validates = exports.Validate = exports.STI = exports.SoftDelete = exports.Scope = exports.ReplicaSafe = exports.Decorators = exports.DreamDbConnection = exports.validateTable = exports.validateColumn = exports.DreamMigrationHelpers = exports.db = exports.pgErrorType = exports.dreamDbConnections = exports.closeAllDbConnections = exports.DreamCLI = exports.DreamBin = void 0;
+exports.DreamSerializer = exports.Attribute = exports.RendersOne = exports.RendersMany = exports.ops = exports.openapiShorthandPrimitiveTypes = exports.openapiPrimitiveTypes = exports.uniq = exports.uncapitalize = exports.standardizeFullyQualifiedModelName = exports.sortBy = exports.snakeify = exports.serializerNameFromFullyQualifiedModelName = exports.round = exports.range = void 0;
 var index_js_1 = require("./bin/index.js");
 Object.defineProperty(exports, "DreamBin", { enumerable: true, get: function () { return index_js_1.default; } });
 var index_js_2 = require("./cli/index.js");
@@ -19,6 +19,8 @@ var validateColumn_js_1 = require("./db/validators/validateColumn.js");
 Object.defineProperty(exports, "validateColumn", { enumerable: true, get: function () { return validateColumn_js_1.default; } });
 var validateTable_js_1 = require("./db/validators/validateTable.js");
 Object.defineProperty(exports, "validateTable", { enumerable: true, get: function () { return validateTable_js_1.default; } });
+var DreamDbConnection_js_2 = require("./db/DreamDbConnection.js");
+Object.defineProperty(exports, "DreamDbConnection", { enumerable: true, get: function () { return DreamDbConnection_js_2.default; } });
 var Decorators_js_1 = require("./decorators/Decorators.js");
 Object.defineProperty(exports, "Decorators", { enumerable: true, get: function () { return Decorators_js_1.default; } });
 var ReplicaSafe_js_1 = require("./decorators/ReplicaSafe.js");

package/dist/esm/src/db/DreamDbConnection.js

@@ -1,7 +1,13 @@
-import { CamelCasePlugin, Kysely, PostgresDialect } from 'kysely';
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';
+import { CamelCasePlugin, Kysely, PostgresDialect } from 'kysely';
 import DreamApplication from '../dream-application/index.js';
 import ConnectionConfRetriever from './ConnectionConfRetriever.js';
 let connections = {};

package/dist/esm/src/db/errors.js

@@ -1,5 +1,12 @@
-import * as pg from 'pg';
-const { DatabaseError } = pg;
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
+// eslint-disable-next-line @typescript-eslint/ban-ts-comment
+// @ts-ignore
+import pg from 'pg';
 export const PG_ERRORS = {
     23505: 'UNIQUE_CONSTRAINT_VIOLATION',
 };
@@ -7,7 +14,7 @@ function pgErrorFromCode(code) {
     return PG_ERRORS[code] || null;
 }
 export function pgErrorType(error) {
-    if (error instanceof DatabaseError)
+    if (error instanceof pg.DatabaseError)
         return pgErrorFromCode(error.code);
     return null;
 }

package/dist/esm/src/dream/Query.js

@@ -1099,6 +1099,9 @@ export default class Query extends ConnectedToDB {
             // base model, it will be underscored (to match the table name), but when the selected column
             // comes back from Kysely camelCased
             aliases.push(field.includes('_') ? camelize(field) : field);
+            //  namespace the selection so that when plucking the same column name from
+            // multpile tables, they don't get saved as the same name (e.g. select results with two `id` columns,
+            // which the pg package then returns in an object with a single `id` key)
             kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(field)} as ${field}`);
         });
         return (await executeDatabaseQuery(kyselyQuery, 'execute')).map(singleResult => aliases.map(alias => singleResult[alias]));
@@ -1800,14 +1803,15 @@ export default class Query extends ConnectedToDB {
         const dream = dreams.find(dream => dream['getAssociationMetadata'](associationName));
         if (!dream)
             return;
-        const association = dream['getAssociationMetadata'](associationName);
+        const { name, alias } = extractAssociationMetadataFromAssociationName(associationName);
+        const association = dream['getAssociationMetadata'](name);
         const dreamClass = dream.constructor;
         const dreamClassToHydrate = association.modelCB();
         if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
             return this.preloadPolymorphicBelongsTo(association, dreams);
         const dreamClassToHydrateColumns = [...dreamClassToHydrate.columns()];
         const throughColumnsToHydrate = [];
-        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), associationName));
+        const columnsToPluck = dreamClassToHydrateColumns.map(column => this.namespaceColumn(column.toString(), alias));
         const asHasAssociation = association;
         if (asHasAssociation.through && asHasAssociation.preloadThroughColumns) {
             if (isObject(asHasAssociation.preloadThroughColumns)) {
@@ -1919,9 +1923,17 @@ export default class Query extends ConnectedToDB {
         }
         return query;
     }
-    // Through associations don't get written into the SQL; they
-    // locate the next association we need to build into the SQL
-    // AND the source to reference on the other side
+    /**
+     * 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.
+     */
     joinsBridgeThroughAssociations({ query, dreamClass, association, previousAssociationTableOrAlias, throughAssociations, joinType, }) {
         if (association.type === 'BelongsTo' || !association.through) {
             return {
@@ -2002,25 +2014,33 @@ export default class Query extends ConnectedToDB {
         previousAssociationTableOrAlias = results.previousAssociationTableOrAlias;
         const throughClass = results.throughClass;
         if (timeToApplyThroughAssociations) {
-            ///////////////////////////////////////////////////////////////////////////////////////
-            // when an association is through another association, `joinsBridgeThroughAssociations`
-            // is called, which eventually calls back to this method, passing in the original
-            // through association as `originalAssociation`
-            ///////////////////////////////////////////////////////////////////////////////////////
+            /**
+             * 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 (thus the
+             * `throughAssociations.length && throughAssociations[0].source === association.as`
+             * above). 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.
+             */
             throughAssociations.forEach((throughAssociation) => {
                 if (throughAssociation.type === 'HasMany') {
                     if (query?.distinctOn && throughAssociation.distinct) {
                         query = query.distinctOn(this.distinctColumnNameForAssociation({
                             association: throughAssociation,
-                            tableNameOrAlias: throughAssociation.as,
+                            tableNameOrAlias: currentAssociationTableOrAlias,
                             foreignKey: throughAssociation.primaryKey(),
                         }));
                     }
                     if (throughAssociation.order) {
                         query = this.applyOrderStatementForAssociation({
                             query,
-                            tableNameOrAlias: throughAssociation.as,
                             association: throughAssociation,
+                            tableNameOrAlias: currentAssociationTableOrAlias,
                         });
                     }
                 }

package/dist/esm/src/dream-application/index.js

@@ -1,3 +1,9 @@
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';

package/dist/esm/src/helpers/db/loadPgClient.js

@@ -1,3 +1,9 @@
+// after building for esm, importing pg using the following:
+//
+//  import * as pg from 'pg'
+//
+// will crash. This is difficult to discover, since it only happens
+// when being imported from our esm build.
 // eslint-disable-next-line @typescript-eslint/ban-ts-comment
 // @ts-ignore
 import pg from 'pg';

package/dist/esm/src/index.js

@@ -6,6 +6,7 @@ export { default as db } from './db/index.js';
 export { default as DreamMigrationHelpers } from './db/migration-helpers/DreamMigrationHelpers.js';
 export { default as validateColumn } from './db/validators/validateColumn.js';
 export { default as validateTable } from './db/validators/validateTable.js';
+export { default as DreamDbConnection } from './db/DreamDbConnection.js';
 export { default as Decorators } from './decorators/Decorators.js';
 export { default as ReplicaSafe } from './decorators/ReplicaSafe.js';
 export { default as Scope } from './decorators/Scope.js';

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

@@ -1045,6 +1045,17 @@ export default class Query<DreamInstance extends Dream, QueryTypeOpts extends Re
      */
     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 applyAssociationOnStatementsToJoinStatement;

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

@@ -6,6 +6,7 @@ export { default as db } from './db/index.js';
 export { default as DreamMigrationHelpers } from './db/migration-helpers/DreamMigrationHelpers.js';
 export { default as validateColumn } from './db/validators/validateColumn.js';
 export { default as validateTable } from './db/validators/validateTable.js';
+export { default as DreamDbConnection } from './db/DreamDbConnection.js';
 export { type WhereStatementForDream, type WhereStatementForDreamClass, } from './decorators/associations/shared.js';
 export { type DecoratorContext } from './decorators/DecoratorContextType.js';
 export { default as Decorators } from './decorators/Decorators.js';

package/docs/assets/navigation.js

@@ -1 +1 @@
-window.navigationData = "data:application/octet-stream;base64,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"
+window.navigationData = "data:application/octet-stream;base64,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"

package/docs/assets/search.js

@@ -1 +1 @@
-window.searchData = "data:application/octet-stream;base64,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";
+window.searchData = "data:application/octet-stream;base64,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";