@rvoh/dream 0.31.5 → 0.32.0

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

@@ -3,6 +3,7 @@ import pluralize from 'pluralize-esm';
 import ConnectedToDB from '../db/ConnectedToDB.js';
 import { SOFT_DELETE_SCOPE_NAME } from '../decorators/class/SoftDelete.js';
 import associationToGetterSetterProp from '../decorators/field/association/associationToGetterSetterProp.js';
+import AssociationDeclaredWithoutAssociatedDreamClass from '../errors/associations/AssociationDeclaredWithoutAssociatedDreamClass.js';
 import CannotAssociateThroughPolymorphic from '../errors/associations/CannotAssociateThroughPolymorphic.js';
 import CannotJoinPolymorphicBelongsToError from '../errors/associations/CannotJoinPolymorphicBelongsToError.js';
 import JoinAttemptedOnMissingAssociation from '../errors/associations/JoinAttemptedOnMissingAssociation.js';
@@ -19,6 +20,7 @@ import MissingRequiredCallbackFunctionToPluckEach from '../errors/MissingRequire
 import NoUpdateAllOnJoins from '../errors/NoUpdateAllOnJoins.js';
 import NoUpdateOnAssociationQuery from '../errors/NoUpdateOnAssociationQuery.js';
 import RecordNotFound from '../errors/RecordNotFound.js';
+import UnexpectedUndefined from '../errors/UnexpectedUndefined.js';
 import CalendarDate from '../helpers/CalendarDate.js';
 import camelize from '../helpers/camelize.js';
 import cloneDeepSafe from '../helpers/cloneDeepSafe.js';
@@ -573,7 +575,10 @@ export default class Query extends ConnectedToDB {
     associationNamesToDreamClassesMap(associationNames, associationsToDreamClassesMap = {}) {
         const namesToAssociationsAndDreamClasses = this.associationNamesToAssociationDataAndDreamClassesMap(associationNames);
         return Object.keys(namesToAssociationsAndDreamClasses).reduce((remap, associationName) => {
-            remap[associationName] = namesToAssociationsAndDreamClasses[associationName].dreamClass;
+            const associationAndDreamClass = namesToAssociationsAndDreamClasses[associationName];
+            if (associationAndDreamClass === undefined)
+                throw new UnexpectedUndefined();
+            remap[associationName] = associationAndDreamClass.dreamClass;
             return remap;
         }, associationsToDreamClassesMap);
     }
@@ -585,7 +590,10 @@ export default class Query extends ConnectedToDB {
     associationNamesToAssociationsMap(associationNames, associationsToAssociations = {}) {
         const namesToAssociationsAndDreamClasses = this.associationNamesToAssociationDataAndDreamClassesMap(associationNames);
         return Object.keys(namesToAssociationsAndDreamClasses).reduce((remap, associationName) => {
-            remap[associationName] = namesToAssociationsAndDreamClasses[associationName].association;
+            const associationAndDreamClass = namesToAssociationsAndDreamClasses[associationName];
+            if (associationAndDreamClass === undefined)
+                throw new UnexpectedUndefined();
+            remap[associationName] = associationAndDreamClass.association;
             return remap;
         }, associationsToAssociations);
     }
@@ -597,6 +605,8 @@ export default class Query extends ConnectedToDB {
         associationNames.reduce((dreamClass, associationName) => {
             const { name, alias } = extractAssociationMetadataFromAssociationName(associationName);
             const association = dreamClass['getAssociationMetadata'](name);
+            if (association === undefined)
+                throw new UnexpectedUndefined();
             const through = association.through;
             if (through) {
                 const { throughAssociation, throughAssociationDreamClass } = this.throughAssociationDetails(dreamClass, through);
@@ -606,6 +616,8 @@ export default class Query extends ConnectedToDB {
                 };
             }
             const nextDreamClass = association.modelCB();
+            if (alias === undefined)
+                throw new UnexpectedUndefined();
             associationsToDreamClassesMap[alias] = { association, dreamClass: nextDreamClass };
             return nextDreamClass;
         }, this.dreamClass);
@@ -616,6 +628,8 @@ export default class Query extends ConnectedToDB {
      */
     throughAssociationDetails(dreamClass, through) {
         const throughAssociation = dreamClass['getAssociationMetadata'](through);
+        if (throughAssociation === undefined)
+            throw new UnexpectedUndefined();
         const throughAssociationDreamClass = throughAssociation.modelCB();
         return { throughAssociation, throughAssociationDreamClass };
     }
@@ -654,7 +668,10 @@ export default class Query extends ConnectedToDB {
         this.addThroughAssociatedDreamClassToInnerJoinDreamClasses(previousDreamClass, association, innerJoinDreamClasses);
         const dreamClasses = [association.modelCB()].flat();
         dreamClasses.forEach(dreamClass => innerJoinDreamClasses.push(dreamClass));
-        return dreamClasses[0];
+        const dreamClass = dreamClasses[0];
+        if (dreamClass === undefined)
+            throw new AssociationDeclaredWithoutAssociatedDreamClass(previousDreamClass, association.as);
+        return dreamClass;
     }
     addThroughAssociatedDreamClassToInnerJoinDreamClasses(dreamClass, _association, innerJoinDreamClasses) {
         const association = _association;
@@ -665,6 +682,8 @@ export default class Query extends ConnectedToDB {
         if (!throughAssociation)
             return;
         const throughDreamClass = [throughAssociation.modelCB()].flat()[0];
+        if (throughDreamClass === undefined)
+            throw new AssociationDeclaredWithoutAssociatedDreamClass(dreamClass, throughAssociation.as);
         innerJoinDreamClasses.push(throughDreamClass);
         this.addThroughAssociatedDreamClassToInnerJoinDreamClasses(dreamClass, throughAssociation, innerJoinDreamClasses);
     }
@@ -1123,8 +1142,12 @@ export default class Query extends ConnectedToDB {
         let nextColumnAliasCounter = 0;
         aliases.forEach((aliasOrExpression) => {
             const alias = extractAssociationMetadataFromAssociationName(aliasOrExpression).alias;
+            if (alias === undefined)
+                throw new UnexpectedUndefined();
             associationAliasToColumnAliasMap[alias] ||= {};
             const aliasedDreamClass = aliasToDreamClassesMap[alias];
+            if (aliasedDreamClass === undefined)
+                throw new UnexpectedUndefined();
             const association = aliasToAssociationsMap[alias];
             const columns = alias === this.baseSqlAlias
                 ? options.columns
@@ -1134,12 +1157,18 @@ export default class Query extends ConnectedToDB {
             columns.forEach((column) => {
                 const columnAlias = `dr${nextColumnAliasCounter++}`;
                 kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(column, alias)} as ${columnAlias}`);
-                associationAliasToColumnAliasMap[alias][column] = columnAlias;
+                const columnAliasMap = associationAliasToColumnAliasMap[alias];
+                if (columnAliasMap === undefined)
+                    throw new UnexpectedUndefined();
+                columnAliasMap[column] = columnAlias;
             });
             if (association?.type === 'HasOne' || association?.type === 'HasMany') {
                 const setupPreloadData = (dbColumnName) => {
                     const columnAlias = `dr${nextColumnAliasCounter++}`;
-                    associationAliasToColumnAliasMap[association.through][dbColumnName] = columnAlias;
+                    const columnAliasMap = associationAliasToColumnAliasMap[association.through];
+                    if (columnAliasMap === undefined)
+                        throw new UnexpectedUndefined();
+                    columnAliasMap[dbColumnName] = columnAlias;
                     kyselyQuery = kyselyQuery.select(`${this.namespaceColumn(dbColumnName, association.through)} as ${columnAlias}`);
                 };
                 if (association.through && association.preloadThroughColumns) {
@@ -1172,20 +1201,35 @@ export default class Query extends ConnectedToDB {
     }
     fleshOutJoinLoadExecutionResults({ currentAlias, singleSqlResult, aliasToDreamIdMap, associationAliasToColumnAliasMap, aliasToAssociationsMap, aliasToDreamClassesMap, leftJoinStatements, }) {
         const dreamClass = aliasToDreamClassesMap[currentAlias];
+        if (dreamClass === undefined)
+            throw new UnexpectedUndefined();
         const columnToColumnAliasMap = associationAliasToColumnAliasMap[currentAlias];
-        const primaryKeyValue = singleSqlResult[columnToColumnAliasMap[dreamClass.primaryKey]];
+        if (columnToColumnAliasMap === undefined)
+            throw new UnexpectedUndefined();
+        const primaryKeyName = dreamClass.primaryKey;
+        if (primaryKeyName === undefined)
+            throw new UnexpectedUndefined();
+        const columnAlias = columnToColumnAliasMap[primaryKeyName];
+        if (columnAlias === undefined)
+            throw new UnexpectedUndefined();
+        const primaryKeyValue = singleSqlResult[columnAlias];
         if (!primaryKeyValue)
             return null;
         aliasToDreamIdMap[currentAlias] ||= new Map();
         if (!aliasToDreamIdMap[currentAlias].get(primaryKeyValue)) {
             const columnValueMap = Object.keys(columnToColumnAliasMap).reduce((columnNameValueMap, columnName) => {
-                columnNameValueMap[columnName] = singleSqlResult[columnToColumnAliasMap[columnName]];
+                const columnAlias = columnToColumnAliasMap[columnName];
+                if (columnAlias === undefined)
+                    throw new UnexpectedUndefined();
+                columnNameValueMap[columnName] = singleSqlResult[columnAlias];
                 return columnNameValueMap;
             }, {});
             const dream = sqlResultToDreamInstance(dreamClass, columnValueMap);
             const association = aliasToAssociationsMap[currentAlias];
             if (association && association.through && association.preloadThroughColumns) {
                 const throughAssociationColumnToColumnAliasMap = associationAliasToColumnAliasMap[association.through];
+                if (throughAssociationColumnToColumnAliasMap === undefined)
+                    throw new UnexpectedUndefined();
                 this.hydratePreloadedThroughColumns({
                     association,
                     columnToColumnAliasMap: throughAssociationColumnToColumnAliasMap,
@@ -1193,12 +1237,14 @@ export default class Query extends ConnectedToDB {
                     singleSqlResult,
                 });
             }
-            aliasToDreamIdMap[protectAgainstPollutingAssignment(currentAlias)].set(primaryKeyValue, dream);
+            aliasToDreamIdMap[protectAgainstPollutingAssignment(currentAlias)]?.set(primaryKeyValue, dream);
         }
         const dream = aliasToDreamIdMap[currentAlias].get(primaryKeyValue);
         Object.keys(leftJoinStatements).forEach(nextAlias => {
             const { name: associationName, alias } = extractAssociationMetadataFromAssociationName(nextAlias);
             const association = dreamClass['getAssociationMetadata'](associationName);
+            if (association === undefined)
+                throw new UnexpectedUndefined();
             const associatedDream = this.fleshOutJoinLoadExecutionResults({
                 currentAlias: alias,
                 singleSqlResult,
@@ -1251,8 +1297,17 @@ export default class Query extends ConnectedToDB {
                 return columnName;
             });
         }
-        columnNames.forEach(columnName => (dream.preloadedThroughColumns[columnNameToPreloadedThroughColumnNameMap[columnName]] =
-            singleSqlResult[columnToColumnAliasMap[columnName]]));
+        columnNames.forEach(columnName => {
+            const preloadedThroughColumnName = columnNameToPreloadedThroughColumnNameMap[columnName];
+            if (preloadedThroughColumnName === undefined)
+                throw new UnexpectedUndefined();
+            const columnAlias = columnToColumnAliasMap[columnName];
+            if (columnAlias === undefined) {
+                throw new UnexpectedUndefined();
+            }
+            ;
+            dream.preloadedThroughColumns[preloadedThroughColumnName] = singleSqlResult[columnAlias];
+        });
     }
     /**
      * Plucks the provided fields from the given dream class table
@@ -1805,6 +1860,8 @@ export default class Query extends ConnectedToDB {
             return;
         const { name, alias } = extractAssociationMetadataFromAssociationName(associationName);
         const association = dream['getAssociationMetadata'](name);
+        if (association === undefined)
+            throw new UnexpectedUndefined();
         const dreamClass = dream.constructor;
         const dreamClassToHydrate = association.modelCB();
         if ((association.polymorphic && association.type === 'BelongsTo') || Array.isArray(dreamClassToHydrate))
@@ -1894,6 +1951,8 @@ export default class Query extends ConnectedToDB {
             return undefined;
         return Object.keys(preloadOnStatements).reduce((agg, key) => {
             const value = preloadOnStatements[key];
+            if (value === undefined)
+                throw new UnexpectedUndefined();
             // filter out plain objects, but not ops and not on/notOn/onAny statements
             // because plain objects are just the next level of nested preload
             if (key === 'on' ||
@@ -2009,7 +2068,7 @@ export default class Query extends ConnectedToDB {
         query = results.query;
         dreamClass = results.dreamClass;
         association = results.association;
-        const timeToApplyThroughAssociations = throughAssociations.length && throughAssociations[0].source === association.as;
+        const timeToApplyThroughAssociations = throughAssociations.length && throughAssociations[0]?.source === association.as;
         const originalPreviousAssociationTableOrAlias = previousAssociationTableOrAlias;
         previousAssociationTableOrAlias = results.previousAssociationTableOrAlias;
         const throughClass = results.throughClass;
@@ -2501,7 +2560,10 @@ export default class Query extends ConnectedToDB {
     checkForQueryViolations() {
         const invalidWhereNotClauses = this.similarityStatementBuilder().whereNotStatementsWithSimilarityClauses();
         if (invalidWhereNotClauses.length) {
-            const { tableName, columnName, opsStatement } = invalidWhereNotClauses[0];
+            const invalidWhereNotClause = invalidWhereNotClauses[0];
+            if (invalidWhereNotClause === undefined)
+                throw new UnexpectedUndefined();
+            const { tableName, columnName, opsStatement } = invalidWhereNotClause;
             throw new CannotNegateSimilarityClause(tableName, columnName, opsStatement.value);
         }
     }

package/dist/esm/src/dream/internal/associations/associationUpdateQuery.js

@@ -1,7 +1,10 @@
+import UnexpectedUndefined from '../../../errors/UnexpectedUndefined.js';
 import namespaceColumn from '../../../helpers/namespaceColumn.js';
 import applyScopeBypassingSettingsToQuery from '../applyScopeBypassingSettingsToQuery.js';
 export default function associationUpdateQuery(dream, txn = null, associationName, { joinOnStatements, bypassAllDefaultScopes, defaultScopesToBypass, }) {
     const association = dream['associationMetadataMap']()[associationName];
+    if (association === undefined)
+        throw new UnexpectedUndefined();
     const associationClass = association.modelCB();
     if (Array.isArray(associationClass)) {
         throw new Error('Cannot update a polymorphic association using associationUpdateQuery');

package/dist/esm/src/dream/internal/associations/createAssociation.js

@@ -1,6 +1,9 @@
 import CannotCreateAssociationWithThroughContext from '../../../errors/associations/CannotCreateAssociationWithThroughContext.js';
+import UnexpectedUndefined from '../../../errors/UnexpectedUndefined.js';
 export default async function createAssociation(dream, txn = null, associationName, opts = {}) {
     const association = dream['associationMetadataMap']()[associationName];
+    if (association === undefined)
+        throw new UnexpectedUndefined();
     if (Array.isArray(association.modelCB())) {
         throw new Error(`
         Cannot create polymorphic associations using createAssociation

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

@@ -1,4 +1,5 @@
 import NonLoadedAssociation from '../../errors/associations/NonLoadedAssociation.js';
+import UnexpectedUndefined from '../../errors/UnexpectedUndefined.js';
 export default function checkSingleValidation(dream, validation) {
     let value;
     try {
@@ -9,6 +10,8 @@ export default function checkSingleValidation(dream, validation) {
             throw error;
     }
     let parsedFloat;
+    let metadataMap;
+    let associationMetadata;
     switch (validation.type) {
         case 'presence':
             return !isBlank(value);
@@ -39,7 +42,11 @@ export default function checkSingleValidation(dream, validation) {
                 validation.options.length.max &&
                 value.length <= validation.options.length.max);
         case 'requiredBelongsTo':
-            return !!(value || dream[dream['associationMetadataMap']()[validation.column].foreignKey()]);
+            metadataMap = dream['associationMetadataMap']();
+            associationMetadata = metadataMap[validation.column];
+            if (associationMetadata === undefined)
+                throw new UnexpectedUndefined();
+            return !!(value || dream[associationMetadata.foreignKey()]);
         default:
             throw new Error(`Unhandled validation type found while running validations: ${validation.type}`);
     }

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

@@ -1,5 +1,9 @@
 export default function extractAssociationMetadataFromAssociationName(associationName) {
-    const name = / as /.test(associationName) ? associationName.split(/ as /)[0] : associationName;
-    const alias = / as /.test(associationName) ? associationName.split(/ as /)[1] : associationName;
-    return { name, alias };
+    if (/ as /.test(associationName)) {
+        const [name, alias] = associationName.split(/ as /);
+        return { name: name ?? associationName, alias: alias ?? associationName };
+    }
+    else {
+        return { name: associationName, alias: associationName };
+    }
 }

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

@@ -15,7 +15,7 @@ Try something like this in your ${this.dreamClass.sanitizedName}'s table getter:
 
 class ${this.dreamClass.sanitizedName} {
   ...
-  public get table() {
+  public override get table() {
     return '${pluralize(snakeify(this.dreamClass.sanitizedName))}'
   }
 }

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

@@ -0,0 +1,11 @@
+export default class UnexpectedUndefined extends Error {
+    constructor() {
+        super();
+    }
+    get message() {
+        return `Undefined detected where it should never happen since we are iterating 
+over keys of an internal object that should not have undefined values.
+
+This was added as part of activating noUncheckedIndexedAccess in tsconfig.`;
+    }
+}

package/dist/esm/src/errors/associations/AssociationDeclaredWithoutAssociatedDreamClass.js

@@ -0,0 +1,14 @@
+export default class AssociationDeclaredWithoutAssociatedDreamClass extends Error {
+    dreamClass;
+    associationName;
+    constructor(dreamClass, associationName) {
+        super();
+        this.dreamClass = dreamClass;
+        this.associationName = associationName;
+    }
+    get message() {
+        return `Association ${String(this.associationName)} on Dream class
+${this.dreamClass.sanitizedName} was declared without the global name
+of a Dream class.`;
+    }
+}

package/dist/esm/src/global-cli/helpers/argAndValue.js

@@ -2,11 +2,11 @@ export default function argAndValue(arg, args) {
     const argIndex = args.findIndex(a => a === arg);
     const foundArg = argIndex === -1 ? null : args[argIndex];
     const foundValue = argIndex === -1 ? null : valueOrNull(argIndex, args);
-    return [foundArg, foundValue];
+    return [foundArg ?? null, foundValue];
 }
 function valueOrNull(argIndex, args) {
-    let value = args[argIndex + 1];
-    if (/--/.test(value))
-        value = null;
+    const value = args[argIndex + 1];
+    if (value === undefined || /--/.test(value))
+        return null;
     return value;
 }

package/dist/esm/src/helpers/CalendarDate.js

@@ -18,7 +18,7 @@ export default class CalendarDate {
         return new CalendarDate(dateTime);
     }
     static fromJSDate(javascriptDate, { zone } = {}) {
-        return new CalendarDate(DateTime.fromJSDate(javascriptDate, { zone }));
+        return new CalendarDate(DateTime.fromJSDate(javascriptDate, zone ? { zone } : undefined));
     }
     static newInvalidDate() {
         return new CalendarDate(null);

package/dist/esm/src/helpers/cli/SchemaBuilder.js

@@ -8,6 +8,7 @@ import { DreamConst } from '../../dream/constants.js';
 import FailedToIdentifyAssociation from '../../errors/schema-builder/FailedToIdentifyAssociation.js';
 import autogeneratedFileDisclaimer from '../../global-cli/helpers/autogeneratedFileMessage.js';
 import camelize from '../camelize.js';
+import compact from '../compact.js';
 import EnvInternal from '../EnvInternal.js';
 import pascalize from '../pascalize.js';
 import sortBy from '../sortBy.js';
@@ -50,9 +51,10 @@ export const globalSchema = {
     }
     globalModelNames() {
         const dreamApp = DreamApplication.getOrFail();
+        const models = dreamApp.models;
         return `{
-      ${Object.keys(dreamApp.models)
-            .map(key => `'${key}': '${dreamApp.models[key].prototype.table}'`)
+      ${Object.keys(models)
+            .map(key => `'${key}': '${models[key]?.prototype?.table}'`)
             .join(',\n      ')}
     }`;
     }
@@ -66,9 +68,14 @@ export const schema = {
   ${Object.keys(schemaData)
             .map(tableName => {
             const tableData = schemaData[tableName];
+            if (tableData === undefined)
+                return '';
             const defaultScopeNames = tableData.scopes.default;
             const namedScopeNames = tableData.scopes.named;
             allDefaultScopeNames = [...allDefaultScopeNames, ...defaultScopeNames];
+            const schemaDatum = schemaData[tableName];
+            if (schemaDatum === undefined)
+                return '';
             return `\
 ${tableName}: {
     primaryKey: '${tableData.primaryKey}',
@@ -81,11 +88,15 @@ ${tableName}: {
       named: ${stringifyArray(namedScopeNames)},
     },
     columns: {
-      ${Object.keys(schemaData[tableName].columns)
+      ${Object.keys(schemaDatum.columns)
                 .sort()
                 .map(columnName => {
                 const columnData = tableData.columns[columnName];
+                if (columnData === undefined)
+                    return '';
                 const kyselyType = this.kyselyType(tableName, columnName, fileContents);
+                if (kyselyType === undefined)
+                    return '';
                 return `${columnName}: {
         coercedType: {} as ${this.coercedType(kyselyType, columnData.dbType)},
         enumType: ${columnData.enumType ? `{} as ${columnData.enumType}` : 'null'},
@@ -98,12 +109,14 @@ ${tableName}: {
             })
                 .join('\n      ')}
     },
-    virtualColumns: ${stringifyArray(schemaData[tableName].virtualColumns)},
+    virtualColumns: ${stringifyArray(schemaDatum.virtualColumns)},
     associations: {
-      ${Object.keys(schemaData[tableName].associations)
+      ${Object.keys(schemaDatum.associations)
                 .sort()
                 .map(associationName => {
                 const associationMetadata = tableData.associations[associationName];
+                if (associationMetadata === undefined)
+                    return '';
                 const whereStatement = associationMetadata.where;
                 const requiredOnClauses = whereStatement === null
                     ? []
@@ -204,6 +217,8 @@ may need to update the table getter in the corresponding Dream.
         return Object.keys(columnData)
             .sort()
             .reduce((acc, key) => {
+            if (columnData[key] === undefined)
+                return acc;
             acc[key] = columnData[key];
             return acc;
         }, {});
@@ -233,6 +248,8 @@ may need to update the table getter in the corresponding Dream.
         for (const model of models.filter(model => model.table === tableName)) {
             for (const associationName of model.associationNames) {
                 const associationMetaData = model['associationMetadataMap']()[associationName];
+                if (associationMetaData === undefined)
+                    continue;
                 if (targetAssociationType && associationMetaData.type !== targetAssociationType)
                     continue;
                 const dreamClassOrClasses = associationMetaData.modelCB();
@@ -284,6 +301,8 @@ may need to update the table getter in the corresponding Dream.
         return Object.keys(tableAssociationData)
             .sort()
             .reduce((acc, key) => {
+            if (tableAssociationData[key] === undefined)
+                return acc;
             acc[key] = tableAssociationData[key];
             return acc;
         }, {});
@@ -293,33 +312,49 @@ may need to update the table getter in the corresponding Dream.
         const exportedConsts = [...fileContents.matchAll(/export\s+const\s+([a-zA-Z0-9_]+)/g)].map(res => res[1]);
         const exportedTypes = [...fileContents.matchAll(/export\s+type\s+([a-zA-Z0-9_]+)/g)].map(res => res[1]);
         const exportedInterfaces = [...fileContents.matchAll(/export\s+interface\s+([a-zA-Z0-9_]+)/g)].map(res => res[1]);
-        const allExports = [...exportedConsts, ...exportedTypes, ...exportedInterfaces];
+        const allExports = compact([...exportedConsts, ...exportedTypes, ...exportedInterfaces]);
         return allExports;
     }
     async getTables() {
         const fileContents = await this.loadDbSyncFile();
         const tableLines = /export interface DB {([^}]*)}/.exec(fileContents)[1];
+        if (tableLines === undefined)
+            return [];
         const tables = tableLines
             .split('\n')
-            .map(line => line.split(':')[0].replace(/\s*/, ''))
+            .map(line => {
+            const stingArray = line.split(':');
+            const substring = stingArray[0];
+            if (substring === undefined)
+                return '';
+            return substring.replace(/\s*/, '');
+        })
             .filter(line => !!line);
         return tables;
     }
     kyselyType(tableName, columnName, fileContents) {
-        const tableLines = /export interface DB {([^}]*)}/.exec(fileContents)[1];
-        const interfaceName = tableLines
+        const tableLinesString = /export interface DB {([^}]*)}/.exec(fileContents)[1];
+        if (tableLinesString === undefined)
+            return '';
+        const tableLines = tableLinesString
             .split('\n')
             .filter(line => !!line)
-            .filter(line => new RegExp(`^  ${tableName}:`).test(line))[0]
-            .split(':')[1]
-            ?.replace(/[\s;]*/g, '');
-        const interfaceLines = new RegExp(`export interface ${interfaceName} {([^}]*)}`).exec(fileContents)[1];
-        const kyselyType = interfaceLines
+            .filter(line => new RegExp(`^  ${tableName}:`).test(line));
+        const tableLine = tableLines[0];
+        if (tableLine === undefined)
+            return '';
+        const interfaceName = tableLine.split(':')[1]?.replace(/[\s;]*/g, '');
+        const interfaceLinesString = new RegExp(`export interface ${interfaceName} {([^}]*)}`).exec(fileContents)[1];
+        if (interfaceLinesString === undefined)
+            return '';
+        const interfaceLines = interfaceLinesString
             .split('\n')
             .filter(line => !!line)
-            .filter(line => new RegExp(`  ${columnName}:`).test(line))[0]
-            .split(':')[1]
-            ?.replace(/[\s;]*/g, '');
+            .filter(line => new RegExp(`  ${columnName}:`).test(line));
+        const interfaceLine = interfaceLines[0];
+        if (interfaceLine === undefined)
+            return '';
+        const kyselyType = interfaceLine.split(':')[1]?.replace(/[\s;]*/g, '');
         return kyselyType;
     }
     coercedType(kyselyType, dbType) {

package/dist/esm/src/helpers/cli/generateDreamContent.js

@@ -25,6 +25,8 @@ export default function generateDreamContent({ fullyQualifiedModelName, columnsW
         : [importStatementForModel(fullyQualifiedModelName, 'ApplicationModel')];
     const attributeStatements = columnsWithTypes.map(attribute => {
         const [attributeName, attributeType, ...descriptors] = attribute.split(':');
+        if (attributeName === undefined)
+            return '';
         const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
         const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
         const associationImportStatement = importStatementForModel(fullyQualifiedModelName, fullyQualifiedAssociatedModelName);
@@ -79,7 +81,7 @@ ${isSTI ? `\n@STI(${parentModelClassName})` : ''}
 export default class ${modelClassName} extends ${isSTI ? parentModelClassName : 'ApplicationModel'} {
 ${isSTI
         ? ''
-        : `  public get table() {
+        : `  public override get table() {
     return '${tableName}' as const
   }
 

package/dist/esm/src/helpers/cli/generateFactoryContent.js

@@ -14,10 +14,14 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
     let firstStringAttr = true;
     for (const attribute of columnsWithTypes) {
         const [attributeName, attributeType, ...descriptors] = attribute.split(':');
+        if (attributeName === undefined)
+            continue;
         const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
         const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
         const associationFactoryImportStatement = `import create${associationModelName} from '${relativeDreamPath('factories', 'factories', fullyQualifiedModelName, fullyQualifiedAssociatedModelName)}'`;
         const associationName = camelize(associationModelName);
+        if (attributeName === undefined)
+            continue;
         if (/_type$/.test(attributeName))
             continue;
         if (!attributeType)
@@ -27,16 +31,16 @@ export default function generateFactoryContent({ fullyQualifiedModelName, column
                 belongsToNames.push(associationName);
                 belongsToTypedNames.push(`${associationName}: ${associationModelName}`);
                 additionalImports.push(associationFactoryImportStatement);
-                associationCreationStatements.push(`attrs.${associationName} ||= await create${associationModelName}()`);
+                associationCreationStatements.push(`attrs.${associationName} ??= await create${associationModelName}()`);
                 break;
             case 'string':
             case 'text':
             case 'citext':
-                stringAttributes.push(`attrs.${camelize(attributeName)} ||= \`${fullyQualifiedModelName} ${camelize(attributeName)} ${firstStringAttr ? '${++counter}' : '${counter}'}\``);
+                stringAttributes.push(`attrs.${camelize(attributeName)} ??= \`${fullyQualifiedModelName} ${camelize(attributeName)} ${firstStringAttr ? '${++counter}' : '${counter}'}\``);
                 firstStringAttr = false;
                 break;
             case 'enum':
-                stringAttributes.push(`attrs.${camelize(attributeName)} ||= '${(descriptors[descriptors.length - 1] || '<tbd>').split(',')[0]}'`);
+                stringAttributes.push(`attrs.${camelize(attributeName)} ??= '${(descriptors[descriptors.length - 1] || '<tbd>').split(',')[0]}'`);
                 break;
             default:
             // noop