@rvoh/dream 2.0.0-alpha.11 → 2.0.0-alpha.13

package/dist/cjs/src/Dream.js

@@ -370,6 +370,12 @@ export default class Dream {
     static get isSTIBase() {
         return !!this.extendedBy?.length && !this.isSTIChild;
     }
+    static stiSiblings() {
+        const stiBase = this.stiBaseClassOrOwnClass;
+        if (!stiBase.isSTIBase)
+            return [];
+        return stiBase.extendedBy;
+    }
     /**
      * @internal
      *
@@ -687,9 +693,9 @@ export default class Dream {
                 return false;
             if (this.explicitUnsafeParamColumns.includes(column))
                 return false;
-            if (this.isBelongsToAssociationForeignKey(column))
+            if (this.isBelongsToAssociationForeignKey(column, { includeStiSiblings: true }))
                 return false;
-            if (this.isBelongsToAssociationPolymorphicTypeField(column))
+            if (this.isBelongsToAssociationPolymorphicTypeField(column, { includeStiSiblings: true }))
                 return false;
             if ((this.isSTIChild || this.isSTIBase) && column === 'type')
                 return false;
@@ -755,13 +761,15 @@ export default class Dream {
      *
      * @returns An array containing all of the associations for this dream class
      */
-    static associationMetadataMap() {
+    static associationMetadataMap(opts = { includeStiSiblings: false }) {
         const allAssociations = [
             ...this.associationMetadataByType.belongsTo,
             ...this.associationMetadataByType.hasOne,
             ...this.associationMetadataByType.hasMany,
         ];
-        const map = {};
+        const map = opts.includeStiSiblings
+            ? this.stiSiblings().reduce((map, sibling) => ({ ...map, ...sibling['associationMetadataMap']() }), {})
+            : {};
         for (const association of allAssociations) {
             map[association.as] = association;
         }
@@ -1837,8 +1845,8 @@ export default class Dream {
      * @param column - A column on this Dream class
      * @returns A boolean
      */
-    static isBelongsToAssociationForeignKey(column) {
-        return this.belongsToAssociationForeignKeys().includes(column);
+    static isBelongsToAssociationForeignKey(column, opts = { includeStiSiblings: false }) {
+        return this.belongsToAssociationForeignKeys(opts).includes(column);
     }
     /**
      * @internal
@@ -1856,8 +1864,8 @@ export default class Dream {
      * @param column - a column on this dream class
      * @returns A boolean
      */
-    static isBelongsToAssociationPolymorphicTypeField(column) {
-        return this.polymorphicTypeColumns().includes(column);
+    static isBelongsToAssociationPolymorphicTypeField(column, opts = { includeStiSiblings: false }) {
+        return this.polymorphicTypeColumns(opts).includes(column);
     }
     /**
      * @internal
@@ -1872,9 +1880,9 @@ export default class Dream {
      *
      * @returns An array of column names that are belongs to foreign keys on this dream class
      */
-    static belongsToAssociationForeignKeys() {
-        const associationMap = this.associationMetadataMap();
-        return this.belongsToAssociationNames().map(belongsToKey => associationMap[belongsToKey]?.foreignKey());
+    static belongsToAssociationForeignKeys(opts = { includeStiSiblings: false }) {
+        const associationMap = this.associationMetadataMap(opts);
+        return this.belongsToAssociationNames(opts).map(belongsToKey => associationMap[belongsToKey]?.foreignKey());
     }
     /**
      * @internal
@@ -1888,9 +1896,9 @@ export default class Dream {
      *
      * @returns An array of column names that are polymorphic type fields on the given dream class
      */
-    static polymorphicTypeColumns() {
-        const associationMap = this.associationMetadataMap();
-        return this.belongsToAssociationNames()
+    static polymorphicTypeColumns(opts = { includeStiSiblings: false }) {
+        const associationMap = this.associationMetadataMap(opts);
+        return this.belongsToAssociationNames(opts)
             .filter(key => associationMap[key]?.polymorphic)
             .map(belongsToKey => associationMap[belongsToKey]?.foreignKeyTypeField());
     }
@@ -1908,8 +1916,8 @@ export default class Dream {
      *
      * @returns An array of belongs to association names
      */
-    static belongsToAssociationNames() {
-        const associationMap = this.associationMetadataMap();
+    static belongsToAssociationNames(opts = { includeStiSiblings: false }) {
+        const associationMap = this.associationMetadataMap(opts);
         return Object.keys(associationMap).filter(key => associationMap[key]?.type === 'BelongsTo');
     }
     /**

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

@@ -7,59 +7,70 @@ import absoluteDreamPath from '../path/absoluteDreamPath.js';
 import snakeify from '../snakeify.js';
 import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
 import uniq from '../uniq.js';
-export default function generateDreamContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, serializer, includeAdminSerializers, connectionName = 'default', }) {
-    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+export default function generateDreamContent(options) {
+    const config = createModelConfig(options);
+    const baseImports = createImportConfig(config, options);
+    const attributesResult = processAttributes(options.columnsWithTypes, config.modelClassName);
+    const allImports = {
+        ...baseImports,
+        modelImportStatements: [...baseImports.modelImportStatements, ...attributesResult.imports],
+    };
+    const importSection = buildImportSection(allImports);
+    const classDeclaration = buildClassDeclaration(config);
+    const tableMethod = buildTableMethod(config);
+    const serializersMethod = buildSerializersMethod(config, options);
+    const fieldsSection = buildFieldsSection(config, attributesResult);
+    return `${importSection}
+
+const deco = new Decorators<typeof ${config.modelClassName}>()
+
+${classDeclaration}
+${tableMethod}${serializersMethod}${fieldsSection}
+}
+`.replace(/^\s*$/gm, '');
+}
+export function createModelConfig(options) {
+    const fullyQualifiedModelName = standardizeFullyQualifiedModelName(options.fullyQualifiedModelName);
     const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
+    const isSTI = !!options.fullyQualifiedParentName;
     let parentModelClassName;
+    if (isSTI) {
+        const standardizedParentName = standardizeFullyQualifiedModelName(options.fullyQualifiedParentName);
+        parentModelClassName = globalClassNameFromFullyQualifiedModelName(standardizedParentName);
+    }
+    const connectionName = options.connectionName || 'default';
+    const applicationModelName = connectionName === 'default' ? 'ApplicationModel' : `${pascalize(connectionName)}ApplicationModel`;
+    const tableName = snakeify(pluralize(fullyQualifiedModelName.replace(/\//g, '_')));
+    return {
+        fullyQualifiedModelName,
+        modelClassName,
+        parentModelClassName,
+        applicationModelName,
+        isSTI,
+        tableName,
+    };
+}
+export function createImportConfig(config, options) {
     const dreamTypeImports = ['DreamColumn'];
     const dreamImports = ['Decorators'];
-    if (serializer)
+    if (options.serializer) {
         dreamTypeImports.push('DreamSerializers');
-    const isSTI = !!fullyQualifiedParentName;
-    if (isSTI) {
-        fullyQualifiedParentName = standardizeFullyQualifiedModelName(fullyQualifiedParentName);
-        parentModelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedParentName);
+    }
+    if (config.isSTI) {
         dreamImports.push('STI');
     }
-    const idTypescriptType = `DreamColumn<${modelClassName}, 'id'>`;
-    const applicationModelName = connectionName === 'default' ? 'ApplicationModel' : `${pascalize(connectionName)}ApplicationModel`;
-    const modelImportStatements = isSTI
-        ? [importStatementForModel(fullyQualifiedParentName)]
-        : [importStatementForModel(applicationModelName)];
-    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(fullyQualifiedAssociatedModelName);
-        if (!attributeType)
-            throw new Error(`must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
-        switch (attributeType) {
-            case 'belongs_to': {
-                modelImportStatements.push(associationImportStatement);
-                const associationName = camelize(fullyQualifiedAssociatedModelName.split('/').pop());
-                const associationForeignKey = `${associationName}Id`;
-                return `
-@deco.BelongsTo('${fullyQualifiedAssociatedModelName}', { on: '${associationForeignKey}'${descriptors.includes('optional') ? ', optional: true' : ''} })
-public ${associationName}: ${associationModelName}${descriptors.includes('optional') ? ' | null' : ''}
-public ${associationForeignKey}: DreamColumn<${modelClassName}, '${associationName}Id'>
-`;
-            }
-            case 'has_one':
-            case 'has_many':
-                return '';
-            case 'encrypted':
-                return `
-@deco.Encrypted()
-public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}\
-`;
-            default:
-                return `
-public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}\
-`;
-        }
-    });
+    const baseModelName = config.isSTI ? options.fullyQualifiedParentName : config.applicationModelName;
+    const modelImportStatements = [importStatementForModel(baseModelName)];
+    return {
+        dreamTypeImports,
+        dreamImports,
+        modelImportStatements,
+    };
+}
+export function processAttributes(columnsWithTypes, modelClassName) {
+    const attributeResults = columnsWithTypes.map(attribute => processAttribute(attribute, modelClassName));
+    const allImports = attributeResults.flatMap(result => result.imports);
+    const attributeStatements = attributeResults.map(result => result.content);
     const formattedFields = attributeStatements
         .filter(attr => !/^\n@/.test(attr))
         .map(s => s.split('\n').join('\n  '))
@@ -69,42 +80,124 @@ public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)
         .map(s => s.split('\n').join('\n  '))
         .join('\n  ')
         .replace(/\n {2}$/, '');
-    let timestamps = `
-  public createdAt: DreamColumn<${modelClassName}, 'createdAt'>
-  public updatedAt: DreamColumn<${modelClassName}, 'updatedAt'>
+    return {
+        content: '', // Not used in this context
+        imports: allImports,
+        formattedFields,
+        formattedDecorators,
+    };
+}
+export function processAttribute(attribute, modelClassName) {
+    const [attributeName, attributeType, ...descriptors] = attribute.split(':');
+    if (attributeName === undefined)
+        return { content: '', imports: [] };
+    if (!attributeType) {
+        throw new Error(`must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
+    }
+    switch (attributeType) {
+        case 'belongs_to':
+            return createBelongsToAttribute(attributeName, descriptors, modelClassName);
+        case 'has_one':
+        case 'has_many':
+            return { content: '', imports: [] };
+        case 'encrypted':
+            return createEncryptedAttribute(attributeName, attribute, modelClassName);
+        default:
+            return createRegularAttribute(attributeName, attribute, modelClassName);
+    }
+}
+export function createBelongsToAttribute(attributeName, descriptors, modelClassName) {
+    const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
+    const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
+    const associationImportStatement = importStatementForModel(fullyQualifiedAssociatedModelName);
+    const associationName = camelize(fullyQualifiedAssociatedModelName.split('/').pop());
+    const associationForeignKey = `${associationName}Id`;
+    const isOptional = descriptors.includes('optional');
+    const content = `
+@deco.BelongsTo('${fullyQualifiedAssociatedModelName}', { on: '${associationForeignKey}'${isOptional ? ', optional: true' : ''} })
+public ${associationName}: ${associationModelName}${isOptional ? ' | null' : ''}
+public ${associationForeignKey}: DreamColumn<${modelClassName}, '${associationName}Id'>
 `;
-    if (!formattedDecorators.length)
-        timestamps = timestamps.replace(/\n$/, '');
-    const tableName = snakeify(pluralize(fullyQualifiedModelName.replace(/\//g, '_')));
-    return `\
-${dreamImports.length ? `import { ${uniq(dreamImports).join(', ')} } from '@rvoh/dream'\n` : ''}import { ${uniq(dreamTypeImports).join(', ')} } from '@rvoh/dream/types'${uniq(modelImportStatements).join('')}
-
-const deco = new Decorators<typeof ${modelClassName}>()
-
-${isSTI ? `\n@STI(${parentModelClassName})` : ''}
-export default class ${modelClassName} extends ${isSTI ? parentModelClassName : applicationModelName} {
-${isSTI
-        ? ''
-        : `  public override get table() {
-    return '${tableName}' as const
+    return {
+        content,
+        imports: [associationImportStatement],
+    };
+}
+export function createEncryptedAttribute(attributeName, attribute, modelClassName) {
+    const content = `
+@deco.Encrypted()
+public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}`;
+    return {
+        content,
+        imports: [],
+    };
+}
+export function createRegularAttribute(attributeName, attribute, modelClassName) {
+    const content = `
+public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}`;
+    return {
+        content,
+        imports: [],
+    };
+}
+function buildImportSection(imports) {
+    const dreamImportLine = imports.dreamImports.length
+        ? `import { ${uniq(imports.dreamImports).join(', ')} } from '@rvoh/dream'\n`
+        : '';
+    const typeImportLine = `import { ${uniq(imports.dreamTypeImports).join(', ')} } from '@rvoh/dream/types'`;
+    const modelImports = uniq(imports.modelImportStatements).join('');
+    return `${dreamImportLine}${typeImportLine}${modelImports}`;
+}
+function buildClassDeclaration(config) {
+    const stiDecorator = config.isSTI ? `@STI(${config.parentModelClassName})\n` : '';
+    const extendsClause = config.isSTI ? config.parentModelClassName : config.applicationModelName;
+    return `${stiDecorator}export default class ${config.modelClassName} extends ${extendsClause} {`;
+}
+function buildTableMethod(config) {
+    if (config.isSTI)
+        return '';
+    return `  public override get table() {
+    return '${config.tableName}' as const
   }
 
-`}${serializer
-        ? `  public ${isSTI ? 'override ' : ''}get serializers(): DreamSerializers<${modelClassName}> {
+`;
+}
+function buildSerializersMethod(config, options) {
+    if (!options.serializer)
+        return '';
+    const overrideKeyword = config.isSTI ? 'override ' : '';
+    const defaultSerializer = serializerGlobalNameFromFullyQualifiedModelName(config.fullyQualifiedModelName);
+    const summarySerializer = serializerGlobalNameFromFullyQualifiedModelName(config.fullyQualifiedModelName, 'summary');
+    let adminSerializers = '';
+    if (options.includeAdminSerializers) {
+        const adminSerializer = defaultSerializer.replace(/Serializer$/, 'AdminSerializer');
+        const adminSummarySerializer = summarySerializer.replace(/SummarySerializer$/, 'AdminSummarySerializer');
+        adminSerializers = `
+      admin: '${adminSerializer}',
+      adminSummary: '${adminSummarySerializer}',`;
+    }
+    return `  public ${overrideKeyword}get serializers(): DreamSerializers<${config.modelClassName}> {
     return {
-      default: '${serializerGlobalNameFromFullyQualifiedModelName(fullyQualifiedModelName)}',
-      summary: '${serializerGlobalNameFromFullyQualifiedModelName(fullyQualifiedModelName, 'summary')}',${!includeAdminSerializers
-            ? ''
-            : `
-      admin: '${serializerGlobalNameFromFullyQualifiedModelName(fullyQualifiedModelName).replace(/Serializer$/, 'AdminSerializer')}',
-      adminSummary: '${serializerGlobalNameFromFullyQualifiedModelName(fullyQualifiedModelName, 'summary').replace(/SummarySerializer$/, 'AdminSummarySerializer')}',`}
+      default: '${defaultSerializer}',
+      summary: '${summarySerializer}',${adminSerializers}
     }
   }
 
-`
-        : ''}${isSTI ? formattedFields : `  public id: ${idTypescriptType}${formattedFields}${timestamps}`}${formattedDecorators}
+`;
 }
-`.replace(/^\s*$/gm, '');
+function buildFieldsSection(config, attributes) {
+    if (config.isSTI) {
+        return `${attributes.formattedFields}${attributes.formattedDecorators}`;
+    }
+    const idField = `  public id: DreamColumn<${config.modelClassName}, 'id'>`;
+    let timestamps = `
+  public createdAt: DreamColumn<${config.modelClassName}, 'createdAt'>
+  public updatedAt: DreamColumn<${config.modelClassName}, 'updatedAt'>
+`;
+    if (!attributes.formattedDecorators.length) {
+        timestamps = timestamps.replace(/\n$/, '');
+    }
+    return `${idField}${attributes.formattedFields}${timestamps}${attributes.formattedDecorators}`;
 }
 function getAttributeType(attribute, modelClassName) {
     return `DreamColumn<${modelClassName}, '${camelize(attribute.split(':')[0])}'>`;

package/dist/esm/src/Dream.js

@@ -370,6 +370,12 @@ export default class Dream {
     static get isSTIBase() {
         return !!this.extendedBy?.length && !this.isSTIChild;
     }
+    static stiSiblings() {
+        const stiBase = this.stiBaseClassOrOwnClass;
+        if (!stiBase.isSTIBase)
+            return [];
+        return stiBase.extendedBy;
+    }
     /**
      * @internal
      *
@@ -687,9 +693,9 @@ export default class Dream {
                 return false;
             if (this.explicitUnsafeParamColumns.includes(column))
                 return false;
-            if (this.isBelongsToAssociationForeignKey(column))
+            if (this.isBelongsToAssociationForeignKey(column, { includeStiSiblings: true }))
                 return false;
-            if (this.isBelongsToAssociationPolymorphicTypeField(column))
+            if (this.isBelongsToAssociationPolymorphicTypeField(column, { includeStiSiblings: true }))
                 return false;
             if ((this.isSTIChild || this.isSTIBase) && column === 'type')
                 return false;
@@ -755,13 +761,15 @@ export default class Dream {
      *
      * @returns An array containing all of the associations for this dream class
      */
-    static associationMetadataMap() {
+    static associationMetadataMap(opts = { includeStiSiblings: false }) {
         const allAssociations = [
             ...this.associationMetadataByType.belongsTo,
             ...this.associationMetadataByType.hasOne,
             ...this.associationMetadataByType.hasMany,
         ];
-        const map = {};
+        const map = opts.includeStiSiblings
+            ? this.stiSiblings().reduce((map, sibling) => ({ ...map, ...sibling['associationMetadataMap']() }), {})
+            : {};
         for (const association of allAssociations) {
             map[association.as] = association;
         }
@@ -1837,8 +1845,8 @@ export default class Dream {
      * @param column - A column on this Dream class
      * @returns A boolean
      */
-    static isBelongsToAssociationForeignKey(column) {
-        return this.belongsToAssociationForeignKeys().includes(column);
+    static isBelongsToAssociationForeignKey(column, opts = { includeStiSiblings: false }) {
+        return this.belongsToAssociationForeignKeys(opts).includes(column);
     }
     /**
      * @internal
@@ -1856,8 +1864,8 @@ export default class Dream {
      * @param column - a column on this dream class
      * @returns A boolean
      */
-    static isBelongsToAssociationPolymorphicTypeField(column) {
-        return this.polymorphicTypeColumns().includes(column);
+    static isBelongsToAssociationPolymorphicTypeField(column, opts = { includeStiSiblings: false }) {
+        return this.polymorphicTypeColumns(opts).includes(column);
     }
     /**
      * @internal
@@ -1872,9 +1880,9 @@ export default class Dream {
      *
      * @returns An array of column names that are belongs to foreign keys on this dream class
      */
-    static belongsToAssociationForeignKeys() {
-        const associationMap = this.associationMetadataMap();
-        return this.belongsToAssociationNames().map(belongsToKey => associationMap[belongsToKey]?.foreignKey());
+    static belongsToAssociationForeignKeys(opts = { includeStiSiblings: false }) {
+        const associationMap = this.associationMetadataMap(opts);
+        return this.belongsToAssociationNames(opts).map(belongsToKey => associationMap[belongsToKey]?.foreignKey());
     }
     /**
      * @internal
@@ -1888,9 +1896,9 @@ export default class Dream {
      *
      * @returns An array of column names that are polymorphic type fields on the given dream class
      */
-    static polymorphicTypeColumns() {
-        const associationMap = this.associationMetadataMap();
-        return this.belongsToAssociationNames()
+    static polymorphicTypeColumns(opts = { includeStiSiblings: false }) {
+        const associationMap = this.associationMetadataMap(opts);
+        return this.belongsToAssociationNames(opts)
             .filter(key => associationMap[key]?.polymorphic)
             .map(belongsToKey => associationMap[belongsToKey]?.foreignKeyTypeField());
     }
@@ -1908,8 +1916,8 @@ export default class Dream {
      *
      * @returns An array of belongs to association names
      */
-    static belongsToAssociationNames() {
-        const associationMap = this.associationMetadataMap();
+    static belongsToAssociationNames(opts = { includeStiSiblings: false }) {
+        const associationMap = this.associationMetadataMap(opts);
         return Object.keys(associationMap).filter(key => associationMap[key]?.type === 'BelongsTo');
     }
     /**