@rvoh/dream 2.0.4 → 2.1.0

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

@@ -1,408 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as path from 'node:path';
-import { CliFileWriter } from '../../cli/CliFileWriter.js';
-import dbTypesFilenameForConnection from '../../db/helpers/dbTypesFilenameForConnection.js';
-import DreamApp from '../../dream-app/index.js';
-import { DreamConst } from '../../dream/constants.js';
-import Query from '../../dream/Query.js';
-import { ExplicitForeignKeyRequired, InvalidComputedForeignKey, } from '../../errors/associations/InvalidComputedForeignKey.js';
-import FailedToIdentifyAssociation from '../../errors/schema-builder/FailedToIdentifyAssociation.js';
-import camelize from '../camelize.js';
-import compact from '../compact.js';
-import EnvInternal from '../EnvInternal.js';
-import intersection from '../intersection.js';
-import pascalize from '../pascalize.js';
-import sortBy from '../sortBy.js';
-import uniq from '../uniq.js';
-import autogeneratedFileDisclaimer from './autoGeneratedFileDisclaimer.js';
-export default class SchemaBuilder {
-    connectionName;
-    hasForeignKeyError = false;
-    constructor(connectionName) {
-        this.connectionName = connectionName;
-    }
-    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.js'`
-            : '';
-        const calendarDateImportStatement = EnvInternal.boolean('DREAM_CORE_DEVELOPMENT')
-            ? "import type CalendarDate from '../../src/helpers/CalendarDate.js'\nimport { type DateTime } from '../../src/helpers/DateTime.js'"
-            : "import { type CalendarDate, type DateTime } from '@rvoh/dream'";
-        const dreamApp = DreamApp.getOrFail();
-        const newSchemaFileContents = `\
-${autogeneratedFileDisclaimer()}
-${calendarDateImportStatement}
-${importStr}
-
-${schemaConstContent}
-
-export const connectionTypeConfig = {
-  passthroughColumns: ${stringifyArray(uniq(passthroughColumns.sort()), { indent: 4 })},
-  allDefaultScopeNames: ${stringifyArray(uniq(allDefaultScopeNames.sort()), { indent: 4 })},
-  globalNames: {
-    models: ${this.globalModelNames()},
-  },
-} as const
-`;
-        const schemaPath = this.connectionName === 'default'
-            ? path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.ts')
-            : path.join(dreamApp.projectRoot, dreamApp.paths.types, `dream.${camelize(this.connectionName)}.ts`);
-        await CliFileWriter.write(schemaPath, newSchemaFileContents);
-    }
-    static async buildGlobalTypes() {
-        const dreamApp = DreamApp.getOrFail();
-        const newSchemaFileContents = `\
-export const globalTypeConfig = {
-  serializers: ${stringifyArray(Object.keys(dreamApp.serializers || {}).sort(), { indent: 6 })},
-} as const
-`;
-        const schemaPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, 'dream.globals.ts');
-        await CliFileWriter.write(schemaPath, newSchemaFileContents);
-    }
-    globalModelNames() {
-        const dreamApp = DreamApp.getOrFail();
-        const models = dreamApp.models;
-        return `{
-      ${Object.keys(models)
-            .filter(key => models[key]?.prototype?.connectionName === this.connectionName)
-            .map(key => `'${key}': '${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];
-            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}: {
-    serializerKeys: ${stringifyArray(tableData.serializerKeys)},
-    scopes: {
-      default: ${stringifyArray(defaultScopeNames)},
-      named: ${stringifyArray(namedScopeNames)},
-    },
-    nonJsonColumnNames: ${stringifyArray(Object.keys(schemaDatum.columns).filter(columnName => !['json', 'jsonb', 'json[]', 'jsonb[]'].includes(tableData.columns[columnName].dbType)))},
-    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'},
-        enumArrayType: ${columnData.enumType ? `[] as ${columnData.enumType}[]` : 'null'},
-        enumValues: ${columnData.enumValues ?? 'null'},
-        dbType: '${columnData.dbType}',
-        allowNull: ${columnData.allowNull},
-        isArray: ${columnData.isArray},
-      },`;
-            })
-                .join('\n      ')}
-    },
-    virtualColumns: ${stringifyArray(schemaDatum.virtualColumns)},
-    associations: {
-      ${Object.keys(schemaDatum.associations)
-                .sort()
-                .map(associationName => {
-                const associationMetadata = tableData.associations[associationName];
-                if (associationMetadata === undefined)
-                    return '';
-                const andStatement = associationMetadata.and;
-                const requiredAndClauses = andStatement === null
-                    ? []
-                    : Object.keys(andStatement).filter(column => andStatement[column] === DreamConst.required);
-                const passthroughAndClauses = andStatement === null
-                    ? []
-                    : Object.keys(andStatement).filter(column => andStatement[column] === DreamConst.passthrough);
-                passthroughColumns = [...passthroughColumns, ...passthroughAndClauses];
-                return `${associationName}: {
-        type: '${associationMetadata.type}',
-        foreignKey: ${associationMetadata.foreignKey ? `'${associationMetadata.foreignKey}'` : 'null'},
-        foreignKeyTypeColumn: ${associationMetadata.foreignKeyTypeColumn ? `'${associationMetadata.foreignKeyTypeColumn}'` : 'null'},
-        tables: ${stringifyArray(associationMetadata.tables)},
-        optional: ${associationMetadata.optional},
-        requiredAndClauses: ${requiredAndClauses.length === 0 ? 'null' : stringifyArray(requiredAndClauses)},
-        passthroughAndClauses: ${passthroughAndClauses.length === 0 ? 'null' : stringifyArray(passthroughAndClauses)},
-      },`;
-            })
-                .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 = DreamApp.getOrFail();
-        const models = Object.values(dreamApp.models).filter(model => model.table === tableName);
-        const maybeModel = models[0];
-        if (!maybeModel)
-            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 baseModel = maybeModel['stiBaseClassOrOwnClass'];
-        const associationData = this.getAssociationData(tableName);
-        const allStiChildren = models.filter(model => model['isSTIChild']);
-        const modelsToCheck = allStiChildren.length ? allStiChildren : [baseModel];
-        // If a table is STI, then we look only at the serializers attached to
-        // all STI children (not the STI base model because the base model may not have any serializers)
-        const eachModelSerializerKeys = modelsToCheck.map(model => {
-            let serializers = {};
-            try {
-                serializers = model?.prototype?.['serializers'] || {};
-            }
-            catch {
-                // no-op
-            }
-            return Object.keys(serializers);
-        });
-        const serializerKeys = intersection(...eachModelSerializerKeys);
-        return {
-            scopes: {
-                default: uniq(models.flatMap(model => model['scopes'].default.map(scopeStatement => scopeStatement.method))),
-                named: uniq(models.flatMap(model => model['scopes'].named.map(scopeStatement => scopeStatement.method))),
-            },
-            columns: await this.getColumnData(tableName, associationData),
-            virtualColumns: uniq(models.flatMap(model => model['virtualAttributes'].map(prop => prop.property) || [])),
-            associations: associationData,
-            serializerKeys,
-        };
-    }
-    async getColumnData(tableName, associationData) {
-        const dbDriverClass = Query.dbDriverClass(this.connectionName);
-        return await dbDriverClass.getColumnData(this.connectionName, tableName, associationData);
-    }
-    enumType(row) {
-        const enumName = pascalize(row.udtName.replace(/\[\]$/, ''));
-        return enumName;
-    }
-    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 = DreamApp.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 (associationMetaData === undefined)
-                    continue;
-                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.and || 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 isThroughAssociation = associationMetaData.through;
-                    if (!isThroughAssociation) {
-                        const _foreignKey = associationMetaData.foreignKey();
-                        foreignKey = _foreignKey;
-                    }
-                }
-                catch (err) {
-                    this.hasForeignKeyError = true;
-                    // console.error(err)
-                }
-                try {
-                    tableAssociationData[associationName] ||= {
-                        tables: [],
-                        type: associationMetaData.type,
-                        polymorphic: associationMetaData.polymorphic,
-                        foreignKey,
-                        foreignKeyTypeColumn: associationMetaData.polymorphic
-                            ? associationMetaData?.foreignKeyTypeField?.() || null
-                            : null,
-                        optional,
-                        and: 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),
-                    ];
-                }
-                catch (error) {
-                    if (!(error instanceof ExplicitForeignKeyRequired || error instanceof InvalidComputedForeignKey))
-                        throw error;
-                }
-            }
-        }
-        return Object.keys(tableAssociationData)
-            .sort()
-            .reduce((acc, key) => {
-            if (tableAssociationData[key] === undefined)
-                return acc;
-            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 = 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 => {
-            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 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));
-        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));
-        const interfaceLine = interfaceLines[0];
-        if (interfaceLine === undefined)
-            return '';
-        const kyselyType = interfaceLine.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 `string${postfix}`;
-                default:
-                    return individualType;
-            }
-        })
-            .join(' | ');
-    }
-    async loadDbSyncFile() {
-        const dreamApp = DreamApp.getOrFail();
-        const dbSyncPath = path.join(dreamApp.projectRoot, dreamApp.paths.types, dbTypesFilenameForConnection(this.connectionName));
-        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/types/src/helpers/cli/SchemaBuilder.d.ts

@@ -1,44 +0,0 @@
-import { DreamConst } from '../../dream/constants.js';
-export default class SchemaBuilder {
-    private connectionName;
-    hasForeignKeyError: boolean;
-    constructor(connectionName: string);
-    build(): Promise<void>;
-    static buildGlobalTypes(): Promise<void>;
-    private globalModelNames;
-    private buildSchemaContent;
-    private getSchemaImports;
-    private tableData;
-    private getColumnData;
-    private enumType;
-    private getSchemaData;
-    private getAssociationData;
-    private getExportedModulesFromDbSync;
-    private getTables;
-    private kyselyType;
-    private coercedType;
-    private loadDbSyncFile;
-}
-export interface SchemaBuilderAssociationData {
-    tables: string[];
-    type: 'BelongsTo' | 'HasOne' | 'HasMany';
-    polymorphic: boolean;
-    optional: boolean | null;
-    foreignKey: string | null;
-    foreignKeyTypeColumn: string | null;
-    and: Record<string, string | typeof DreamConst.passthrough | typeof DreamConst.required> | null;
-}
-export interface SchemaBuilderColumnData {
-    dbType: string;
-    allowNull: boolean;
-    enumType: string | null;
-    enumValues: string | null;
-    foreignKey: string | null;
-    isArray: boolean;
-}
-export interface SchemaBuilderInformationSchemaRow {
-    columnName: string;
-    udtName: string;
-    dataType: string;
-    isNullable: 'YES' | 'NO';
-}