@rvoh/dream 0.29.1

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

@@ -0,0 +1,375 @@
+import * as fs from 'fs/promises';
+import { sql } from 'kysely';
+import * as path from 'path';
+import { isPrimitiveDataType } from '../../db/dataTypes.js';
+import _db from '../../db/index.js';
+import DreamApplication from '../../dream-application/index.js';
+import { DreamConst } from '../../dream/types.js';
+import FailedToIdentifyAssociation from '../../errors/schema-builder/FailedToIdentifyAssociation.js';
+import autogeneratedFileDisclaimer from '../../global-cli/helpers/autogeneratedFileMessage.js';
+import camelize from '../camelize.js';
+import EnvInternal from '../EnvInternal.js';
+import pascalize from '../pascalize.js';
+import sortBy from '../sortBy.js';
+import uniq from '../uniq.js';
+export default class SchemaBuilder {
+    async build() {
+        const { schemaConstContent, passthroughColumns, allDefaultScopeNames } = await this.buildSchemaContent();
+        const imports = await this.getSchemaImports(schemaConstContent);
+        const importStr = imports.length
+            ? `\
+import {
+  ${imports.sort().join(',\n  ')}
+} from './db'`
+            : '';
+        const calendarDateImportStatement = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT')
+            ? "import CalendarDate from '../../src/helpers/CalendarDate'"
+            : "import { CalendarDate } from '@rvohealth/dream'";
+        const dreamApp = DreamApplication.getOrFail();
+        const newSchemaFileContents = `\
+${autogeneratedFileDisclaimer()}
+${calendarDateImportStatement}
+import { DateTime } from 'luxon'
+${importStr}
+
+${schemaConstContent}
+
+export const globalSchema = {
+  passthroughColumns: ${stringifyArray(uniq(passthroughColumns.sort()), { indent: 4 })},
+  allDefaultScopeNames: ${stringifyArray(uniq(allDefaultScopeNames.sort()), { indent: 4 })},
+  globalNames: {
+    models: ${this.globalModelNames()},
+    serializers: ${stringifyArray(Object.keys(dreamApp.serializers || {}).sort(), { indent: 6 })},
+  },
+} as const
+`;
+        // const newSchemaFileContents = `\
+        // ${schemaConstContent}
+        // `
+        const schemaPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.ts');
+        await fs.writeFile(schemaPath, newSchemaFileContents);
+    }
+    globalModelNames() {
+        const dreamApp = DreamApplication.getOrFail();
+        return `{
+      ${Object.keys(dreamApp.models)
+            .map(key => `'${key}': '${dreamApp.models[key].prototype.table}'`)
+            .join(',\n      ')}
+    }`;
+    }
+    async buildSchemaContent() {
+        let passthroughColumns = [];
+        let allDefaultScopeNames = [];
+        const schemaData = await this.getSchemaData();
+        const fileContents = await this.loadDbSyncFile();
+        const schemaConstContent = `\
+export const schema = {
+  ${Object.keys(schemaData)
+            .map(tableName => {
+            const tableData = schemaData[tableName];
+            const defaultScopeNames = tableData.scopes.default;
+            const namedScopeNames = tableData.scopes.named;
+            allDefaultScopeNames = [...allDefaultScopeNames, ...defaultScopeNames];
+            return `\
+${tableName}: {
+    primaryKey: '${tableData.primaryKey}',
+    createdAtField: '${tableData.createdAtField}',
+    updatedAtField: '${tableData.updatedAtField}',
+    deletedAtField: '${tableData.deletedAtField}',
+    serializerKeys: ${stringifyArray(tableData.serializerKeys)},
+    scopes: {
+      default: ${stringifyArray(defaultScopeNames)},
+      named: ${stringifyArray(namedScopeNames)},
+    },
+    columns: {
+      ${Object.keys(schemaData[tableName].columns)
+                .sort()
+                .map(columnName => {
+                const columnData = tableData.columns[columnName];
+                const kyselyType = this.kyselyType(tableName, columnName, fileContents);
+                return `${columnName}: {
+        coercedType: {} as ${this.coercedType(kyselyType, columnData.dbType)},
+        enumType: ${columnData.enumType ? `{} as ${columnData.enumType}` : 'null'},
+        enumArrayType: ${columnData.enumType ? `[] as ${columnData.enumType}[]` : 'null'},
+        enumValues: ${columnData.enumValues ?? 'null'},
+        dbType: '${columnData.dbType}',
+        allowNull: ${columnData.allowNull},
+        isArray: ${columnData.isArray},
+      },`;
+            })
+                .join('\n      ')}
+    },
+    virtualColumns: ${stringifyArray(schemaData[tableName].virtualColumns)},
+    associations: {
+      ${Object.keys(schemaData[tableName].associations)
+                .sort()
+                .map(associationName => {
+                const associationMetadata = tableData.associations[associationName];
+                const whereStatement = associationMetadata.where;
+                const requiredOnClauses = whereStatement === null
+                    ? []
+                    : Object.keys(whereStatement).filter(column => whereStatement[column] === DreamConst.required);
+                passthroughColumns =
+                    whereStatement === null
+                        ? passthroughColumns
+                        : [
+                            ...passthroughColumns,
+                            ...Object.keys(whereStatement).filter(column => whereStatement[column] === DreamConst.passthrough),
+                        ];
+                return `${associationName}: {
+        type: '${associationMetadata.type}',
+        foreignKey: ${associationMetadata.foreignKey ? `'${associationMetadata.foreignKey}'` : 'null'},
+        tables: ${stringifyArray(associationMetadata.tables)},
+        optional: ${associationMetadata.optional},
+        requiredOnClauses: ${requiredOnClauses.length === 0 ? 'null' : stringifyArray(requiredOnClauses)},
+      },`;
+            })
+                .join('\n      ')}
+    },
+  },\
+`;
+        })
+            .join('\n  ')}
+} as const`;
+        return { schemaConstContent, passthroughColumns, allDefaultScopeNames };
+    }
+    async getSchemaImports(schemaContent) {
+        const allExports = await this.getExportedModulesFromDbSync();
+        const schemaContentWithoutImports = schemaContent.replace(/import {[^}]*}/gm, '');
+        return allExports.filter(exportedModule => {
+            if (new RegExp(`coercedType: {} as ${exportedModule}`).test(schemaContentWithoutImports))
+                return true;
+            if (new RegExp(`coercedType: {} as ArrayType<${exportedModule}`).test(schemaContentWithoutImports))
+                return true;
+            if (new RegExp(`enumType: {} as ${exportedModule}`).test(schemaContentWithoutImports))
+                return true;
+            if (new RegExp(`enumValues: ${exportedModule}`).test(schemaContentWithoutImports))
+                return true;
+            return false;
+        });
+    }
+    async tableData(tableName) {
+        const dreamApp = DreamApplication.getOrFail();
+        const models = Object.values(dreamApp.models);
+        const model = models.find(model => model.table === tableName);
+        if (!model)
+            throw new Error(`
+Could not find a Dream model with table "${tableName}".
+
+If you recently changed the name of a table in a migration, you
+may need to update the table getter in the corresponding Dream.
+`);
+        const associationData = this.getAssociationData(tableName);
+        let serializers;
+        try {
+            serializers =
+                model?.prototype?.['serializers'] || {};
+        }
+        catch {
+            serializers = {};
+        }
+        return {
+            primaryKey: model.prototype.primaryKey,
+            createdAtField: model.prototype.createdAtField,
+            updatedAtField: model.prototype.updatedAtField,
+            deletedAtField: model.prototype.deletedAtField,
+            scopes: {
+                default: model['scopes'].default.map(scopeStatement => scopeStatement.method),
+                named: model['scopes'].named.map(scopeStatement => scopeStatement.method),
+            },
+            columns: await this.getColumnData(tableName, associationData),
+            virtualColumns: this.getVirtualColumns(tableName),
+            associations: associationData,
+            serializerKeys: Object.keys(serializers),
+        };
+    }
+    async getColumnData(tableName, associationData) {
+        const db = _db('primary');
+        const sqlQuery = sql `SELECT column_name, udt_name::regtype, is_nullable, data_type FROM information_schema.columns WHERE table_name = ${tableName}`;
+        const columnToDBTypeMap = await sqlQuery.execute(db);
+        const rows = columnToDBTypeMap.rows;
+        const columnData = {};
+        rows.forEach(row => {
+            const isEnum = ['USER-DEFINED', 'ARRAY'].includes(row.dataType) && !isPrimitiveDataType(row.udtName);
+            const isArray = ['ARRAY'].includes(row.dataType);
+            const associationMetadata = associationData[row.columnName];
+            columnData[camelize(row.columnName)] = {
+                dbType: row.udtName,
+                allowNull: row.isNullable === 'YES',
+                enumType: isEnum ? this.enumType(row) : null,
+                enumValues: isEnum ? `${this.enumType(row)}Values` : null,
+                isArray,
+                foreignKey: associationMetadata?.foreignKey || null,
+            };
+        });
+        return Object.keys(columnData)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = columnData[key];
+            return acc;
+        }, {});
+    }
+    enumType(row) {
+        const enumName = pascalize(row.udtName.replace(/\[\]$/, ''));
+        return enumName;
+    }
+    getVirtualColumns(tableName) {
+        const dreamApp = DreamApplication.getOrFail();
+        const models = sortBy(Object.values(dreamApp.models), m => m.table);
+        const model = models.find(model => model.table === tableName);
+        return model?.['virtualAttributes']?.map(prop => prop.property) || [];
+    }
+    async getSchemaData() {
+        const tables = await this.getTables();
+        const schemaData = {};
+        for (const table of tables) {
+            schemaData[table] = await this.tableData(table);
+        }
+        return schemaData;
+    }
+    getAssociationData(tableName, targetAssociationType) {
+        const dreamApp = DreamApplication.getOrFail();
+        const models = sortBy(Object.values(dreamApp.models), m => m.table);
+        const tableAssociationData = {};
+        for (const model of models.filter(model => model.table === tableName)) {
+            for (const associationName of model.associationNames) {
+                const associationMetaData = model['associationMetadataMap']()[associationName];
+                if (targetAssociationType && associationMetaData.type !== targetAssociationType)
+                    continue;
+                const dreamClassOrClasses = associationMetaData.modelCB();
+                if (!dreamClassOrClasses)
+                    throw new FailedToIdentifyAssociation(model, associationMetaData.type, associationName, associationMetaData.globalAssociationNameOrNames);
+                const optional = associationMetaData.type === 'BelongsTo' ? associationMetaData.optional === true : null;
+                const where = associationMetaData.type === 'HasMany' || associationMetaData.type === 'HasOne'
+                    ? associationMetaData.on || null
+                    : null;
+                // NOTE
+                // this try-catch is here because the SchemaBuilder currently needs to be run twice to generate foreignKey
+                // correctly. The first time will raise, since calling Dream.columns is dependant on the schema const to
+                // introspect columns during a foreign key check. This will be repaired once kysely types have been successfully
+                // split off into a separate file from the types we diliver in types/dream.ts
+                let foreignKey = null;
+                try {
+                    const _foreignKey = associationMetaData.foreignKey();
+                    foreignKey = _foreignKey;
+                }
+                catch {
+                    // noop
+                }
+                tableAssociationData[associationName] ||= {
+                    tables: [],
+                    type: associationMetaData.type,
+                    polymorphic: associationMetaData.polymorphic,
+                    foreignKey,
+                    optional,
+                    where,
+                };
+                if (foreignKey)
+                    tableAssociationData[associationName]['foreignKey'] = foreignKey;
+                if (Array.isArray(dreamClassOrClasses)) {
+                    const tables = dreamClassOrClasses.map(dreamClass => dreamClass.table);
+                    tableAssociationData[associationName].tables = [
+                        ...tableAssociationData[associationName].tables,
+                        ...tables,
+                    ];
+                }
+                else {
+                    tableAssociationData[associationName].tables.push(dreamClassOrClasses.table);
+                }
+                // guarantee unique
+                tableAssociationData[associationName].tables = [
+                    ...new Set(tableAssociationData[associationName].tables),
+                ];
+            }
+        }
+        return Object.keys(tableAssociationData)
+            .sort()
+            .reduce((acc, key) => {
+            acc[key] = tableAssociationData[key];
+            return acc;
+        }, {});
+    }
+    async getExportedModulesFromDbSync() {
+        const fileContents = await this.loadDbSyncFile();
+        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];
+        return allExports;
+    }
+    async getTables() {
+        const fileContents = await this.loadDbSyncFile();
+        const tableLines = /export interface DB {([^}]*)}/.exec(fileContents)[1];
+        const tables = tableLines
+            .split('\n')
+            .map(line => line.split(':')[0].replace(/\s*/, ''))
+            .filter(line => !!line);
+        return tables;
+    }
+    kyselyType(tableName, columnName, fileContents) {
+        const tableLines = /export interface DB {([^}]*)}/.exec(fileContents)[1];
+        const interfaceName = tableLines
+            .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
+            .split('\n')
+            .filter(line => !!line)
+            .filter(line => new RegExp(`  ${columnName}:`).test(line))[0]
+            .split(':')[1]
+            ?.replace(/[\s;]*/g, '');
+        return kyselyType;
+    }
+    coercedType(kyselyType, dbType) {
+        const postfix = /\[\]$/.test(dbType) ? '[]' : '';
+        return kyselyType
+            .replace(/\s/g, '')
+            .replace(/Generated<(.*)>/g, '$1')
+            .replace(/ArrayType<(.*)>/g, '$1[]')
+            .split('|')
+            .map(individualType => {
+            switch (individualType) {
+                case 'Numeric':
+                case 'Numeric[]':
+                    return `number${postfix}`;
+                case 'Timestamp':
+                case 'Timestamp[]':
+                    return /^date[[\]]*$/.test(dbType) ? `CalendarDate${postfix}` : `DateTime${postfix}`;
+                case 'Int8':
+                case 'Int8[]':
+                    return `IdType${postfix}`;
+                default:
+                    return individualType;
+            }
+        })
+            .join(' | ');
+    }
+    async loadDbSyncFile() {
+        const dreamApp = DreamApplication.getOrFail();
+        const dbSyncPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'db.ts');
+        return (await fs.readFile(dbSyncPath)).toString();
+    }
+}
+function stringifyArray(arr = [], { indent } = {}) {
+    if (indent && arr.length > 3) {
+        let spaces = '';
+        for (let i = 0; i < indent; i++) {
+            spaces = `${spaces} `;
+        }
+        return `[
+${spaces}${[...arr]
+            .sort()
+            .map(val => `'${val}'`)
+            .join(`,\n${spaces}`)}
+${spaces.replace(/\s{2}$/, '')}]`;
+    }
+    else {
+        return `[${[...arr]
+            .sort()
+            .map(val => `'${val}'`)
+            .join(', ')}]`;
+    }
+}

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

@@ -0,0 +1,45 @@
+import * as fs from 'fs/promises';
+import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
+import dreamPath from '../path/dreamPath.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import generateDreamContent from './generateDreamContent.js';
+import generateFactory from './generateFactory.js';
+import generateMigration from './generateMigration.js';
+import generateSerializer from './generateSerializer.js';
+import generateUnitSpec from './generateUnitSpec.js';
+export default async function generateDream({ fullyQualifiedModelName, columnsWithTypes, options, fullyQualifiedParentName, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('models'), `${fullyQualifiedModelName}.ts`);
+    try {
+        console.log(`generating dream: ${relFilePath}`);
+        await fs.mkdir(absDirPath, { recursive: true });
+        await fs.writeFile(absFilePath, generateDreamContent({
+            fullyQualifiedModelName,
+            columnsWithTypes,
+            fullyQualifiedParentName,
+            serializer: options.serializer,
+        }));
+    }
+    catch (error) {
+        throw new Error(`
+      Something happened while trying to create the Dream file:
+        ${relFilePath}
+
+      Does this file already exist? Here is the error that was raised:
+        ${error.message}
+    `);
+    }
+    await generateUnitSpec({ fullyQualifiedModelName });
+    await generateFactory({ fullyQualifiedModelName, columnsWithTypes });
+    if (options.serializer)
+        await generateSerializer({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName });
+    const isSTI = !!fullyQualifiedParentName;
+    if (columnsWithTypes.length || !isSTI) {
+        await generateMigration({
+            migrationName: fullyQualifiedModelName,
+            columnsWithTypes,
+            fullyQualifiedModelName,
+            fullyQualifiedParentName,
+        });
+    }
+}

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

@@ -0,0 +1,104 @@
+import pluralize from 'pluralize-esm';
+import camelize from '../camelize.js';
+import globalClassNameFromFullyQualifiedModelName from '../globalClassNameFromFullyQualifiedModelName.js';
+import relativeDreamPath from '../path/relativeDreamPath.js';
+import serializerNameFromFullyQualifiedModelName from '../serializerNameFromFullyQualifiedModelName.js';
+import snakeify from '../snakeify.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import uniq from '../uniq.js';
+export default function generateDreamContent({ fullyQualifiedModelName, columnsWithTypes, fullyQualifiedParentName, serializer, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
+    let parentModelClassName;
+    const dreamImports = ['Decorators', 'DreamColumn'];
+    if (serializer)
+        dreamImports.push('DreamSerializers');
+    const isSTI = !!fullyQualifiedParentName;
+    if (isSTI) {
+        fullyQualifiedParentName = standardizeFullyQualifiedModelName(fullyQualifiedParentName);
+        parentModelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedParentName);
+        dreamImports.push('STI');
+    }
+    const idTypescriptType = `DreamColumn<${modelClassName}, 'id'>`;
+    const modelImportStatements = isSTI
+        ? [importStatementForModel(fullyQualifiedModelName, fullyQualifiedParentName)]
+        : [importStatementForModel(fullyQualifiedModelName, 'ApplicationModel')];
+    const attributeStatements = columnsWithTypes.map(attribute => {
+        const [attributeName, attributeType, ...descriptors] = attribute.split(':');
+        const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
+        const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
+        const associationImportStatement = importStatementForModel(fullyQualifiedModelName, fullyQualifiedAssociatedModelName);
+        const associationName = camelize(associationModelName);
+        if (!attributeType)
+            throw new Error(`must pass a column type for ${attributeName} (i.e. ${attributeName}:string)`);
+        switch (attributeType) {
+            case 'belongs_to':
+                modelImportStatements.push(associationImportStatement);
+                return `
+@Deco.BelongsTo('${fullyQualifiedAssociatedModelName}'${descriptors.includes('optional') ? ', { optional: true }' : ''})
+public ${associationName}: ${associationModelName}${descriptors.includes('optional') ? ' | null' : ''}
+public ${associationName}Id: DreamColumn<${modelClassName}, '${associationName}Id'>
+`;
+            case 'has_one':
+            case 'has_many':
+                return '';
+            case 'encrypted':
+                dreamImports.push('Encrypted');
+                return `
+@Encrypted()
+public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}\
+`;
+            default:
+                return `
+public ${camelize(attributeName)}: ${getAttributeType(attribute, modelClassName)}\
+`;
+        }
+    });
+    const formattedFields = attributeStatements
+        .filter(attr => !/^\n@/.test(attr))
+        .map(s => s.split('\n').join('\n  '))
+        .join('');
+    const formattedDecorators = attributeStatements
+        .filter(attr => /^\n@/.test(attr))
+        .map(s => s.split('\n').join('\n  '))
+        .join('\n  ')
+        .replace(/\n {2}$/, '');
+    let timestamps = `
+  public createdAt: DreamColumn<${modelClassName}, 'createdAt'>
+  public updatedAt: DreamColumn<${modelClassName}, 'updatedAt'>
+`;
+    if (!formattedDecorators.length)
+        timestamps = timestamps.replace(/\n$/, '');
+    const tableName = snakeify(pluralize(fullyQualifiedModelName.replace(/\//g, '_')));
+    return `\
+import { ${uniq(dreamImports).join(', ')} } from '@rvohealth/dream'${uniq(modelImportStatements).join('')}
+
+const Deco = new Decorators<InstanceType<typeof ${modelClassName}>>()
+
+${isSTI ? `\n@STI(${parentModelClassName})` : ''}
+export default class ${modelClassName} extends ${isSTI ? parentModelClassName : 'ApplicationModel'} {
+${isSTI
+        ? ''
+        : `  public get table() {
+    return '${tableName}' as const
+  }
+
+`}${serializer
+        ? `  public get serializers(): DreamSerializers<${modelClassName}> {
+    return {
+      default: '${serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName)}',
+      summary: '${serializerNameFromFullyQualifiedModelName(fullyQualifiedModelName, 'summary')}',
+    }
+  }
+
+`
+        : ''}${isSTI ? formattedFields : `  public id: ${idTypescriptType}${formattedFields}${timestamps}`}${formattedDecorators}
+}
+`.replace(/^\s*$/gm, '');
+}
+function getAttributeType(attribute, modelClassName) {
+    return `DreamColumn<${modelClassName}, '${camelize(attribute.split(':')[0])}'>`;
+}
+function importStatementForModel(originModelName, destinationModelName = originModelName) {
+    return `\nimport ${globalClassNameFromFullyQualifiedModelName(destinationModelName)} from '${relativeDreamPath('models', 'models', originModelName, destinationModelName)}'`;
+}

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

@@ -0,0 +1,23 @@
+import * as fs from 'fs/promises';
+import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
+import dreamPath from '../path/dreamPath.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import generateFactoryContent from './generateFactoryContent.js';
+export default async function generateFactory({ fullyQualifiedModelName, columnsWithTypes, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const { relFilePath, absDirPath, absFilePath } = dreamFileAndDirPaths(dreamPath('factories'), `${fullyQualifiedModelName}Factory.ts`);
+    try {
+        console.log(`generating factory: ${relFilePath}`);
+        await fs.mkdir(absDirPath, { recursive: true });
+        await fs.writeFile(absFilePath, generateFactoryContent({ fullyQualifiedModelName, columnsWithTypes }));
+    }
+    catch (error) {
+        throw new Error(`
+      Something happened while trying to create the spec file:
+        ${relFilePath}
+
+      Does this file already exist? Here is the error that was raised:
+        ${error.message}
+    `);
+    }
+}

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

@@ -0,0 +1,55 @@
+import camelize from '../camelize.js';
+import globalClassNameFromFullyQualifiedModelName from '../globalClassNameFromFullyQualifiedModelName.js';
+import relativeDreamPath from '../path/relativeDreamPath.js';
+import standardizeFullyQualifiedModelName from '../standardizeFullyQualifiedModelName.js';
+import uniq from '../uniq.js';
+export default function generateFactoryContent({ fullyQualifiedModelName, columnsWithTypes, }) {
+    fullyQualifiedModelName = standardizeFullyQualifiedModelName(fullyQualifiedModelName);
+    const dreamImports = ['UpdateableProperties'];
+    const additionalImports = [];
+    const belongsToNames = [];
+    const belongsToTypedNames = [];
+    const associationCreationStatements = [];
+    const stringAttributes = [];
+    let firstStringAttr = true;
+    for (const attribute of columnsWithTypes) {
+        const [attributeName, attributeType, ...descriptors] = attribute.split(':');
+        const fullyQualifiedAssociatedModelName = standardizeFullyQualifiedModelName(attributeName);
+        const associationModelName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedAssociatedModelName);
+        const associationFactoryImportStatement = `import create${associationModelName} from '${relativeDreamPath('factories', 'factories', fullyQualifiedModelName, fullyQualifiedAssociatedModelName)}'`;
+        const associationName = camelize(associationModelName);
+        if (/_type$/.test(attributeName))
+            continue;
+        if (!attributeType)
+            throw new Error(`Must pass a column type for ${fullyQualifiedAssociatedModelName} (i.e. ${fullyQualifiedAssociatedModelName}:string)`);
+        switch (attributeType) {
+            case 'belongs_to':
+                belongsToNames.push(associationName);
+                belongsToTypedNames.push(`${associationName}: ${associationModelName}`);
+                additionalImports.push(associationFactoryImportStatement);
+                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}'}\``);
+                firstStringAttr = false;
+                break;
+            case 'enum':
+                stringAttributes.push(`attrs.${camelize(attributeName)} ||= '${(descriptors[descriptors.length - 1] || '<tbd>').split(',')[0]}'`);
+                break;
+            default:
+            // noop
+        }
+    }
+    const relativePath = relativeDreamPath('factories', 'models', fullyQualifiedModelName);
+    const modelClassName = globalClassNameFromFullyQualifiedModelName(fullyQualifiedModelName);
+    return `\
+import { ${uniq(dreamImports).join(', ')} } from '@rvohealth/dream'
+import ${modelClassName} from '${relativePath}'${additionalImports.length ? '\n' + uniq(additionalImports).join('\n') : ''}
+${stringAttributes.length ? '\nlet counter = 0\n' : ''}
+export default async function create${modelClassName}(attrs: UpdateableProperties<${modelClassName}> = {}) {
+  ${associationCreationStatements.length ? associationCreationStatements.join('\n  ') + '\n  ' : ''}${stringAttributes.length ? stringAttributes.join('\n  ') + '\n  ' : ''}return await ${modelClassName}.create(attrs)
+}
+`;
+}

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

@@ -0,0 +1,53 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import pluralize from 'pluralize-esm';
+import generateMigrationContent from '../cli/generateMigrationContent.js';
+import primaryKeyType from '../db/primaryKeyType.js';
+import hyphenize from '../hyphenize.js';
+import migrationVersion from '../migrationVersion.js';
+import pascalizePath from '../pascalizePath.js';
+import dreamFileAndDirPaths from '../path/dreamFileAndDirPaths.js';
+import dreamPath from '../path/dreamPath.js';
+import snakeify from '../snakeify.js';
+import generateStiMigrationContent from './generateStiMigrationContent.js';
+export default async function generateMigration({ migrationName, columnsWithTypes, fullyQualifiedModelName, fullyQualifiedParentName, }) {
+    const { relFilePath, absFilePath } = dreamFileAndDirPaths(path.join(dreamPath('db'), 'migrations'), `${migrationVersion()}-${hyphenize(migrationName).replace(/\//g, '-')}.ts`);
+    const isSTI = !!fullyQualifiedParentName;
+    let finalContent = '';
+    if (isSTI) {
+        finalContent = generateStiMigrationContent({
+            table: snakeify(pluralize(pascalizePath(fullyQualifiedParentName))),
+            columnsWithTypes,
+            primaryKeyType: primaryKeyType(),
+        });
+    }
+    else if (fullyQualifiedModelName) {
+        finalContent = generateMigrationContent({
+            table: snakeify(pluralize(pascalizePath(fullyQualifiedModelName))),
+            columnsWithTypes,
+            primaryKeyType: primaryKeyType(),
+        });
+    }
+    else {
+        const tableName = migrationName.match(/-to-(.+)$/)?.[1];
+        finalContent = generateMigrationContent({
+            table: tableName ? pluralize(snakeify(tableName)) : '<table-name>',
+            columnsWithTypes,
+            primaryKeyType: primaryKeyType(),
+            createOrAlter: 'alter',
+        });
+    }
+    try {
+        console.log(`generating migration: ${relFilePath}`);
+        await fs.writeFile(absFilePath, finalContent);
+    }
+    catch (error) {
+        throw new Error(`
+      Something happened while trying to create the migration file:
+        ${relFilePath}
+
+      Does this file already exist? Here is the error that was raised:
+        ${error.message}
+    `);
+    }
+}