@tsofist/schema-forge 2.11.0 → 3.0.0-next.1

package/lib/artefacts-policy.d.ts

@@ -0,0 +1,3 @@
+export declare const KEEP_SPEC_ARTEFACTS: boolean;
+export declare const KEEP_GEN_ARTEFACTS: boolean;
+//# sourceMappingURL=artefacts-policy.d.ts.map

package/lib/artefacts-policy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"artefacts-policy.d.ts","sourceRoot":"","sources":["../src/artefacts-policy.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,mBAAmB,SAAkC,CAAC;AACnE,eAAO,MAAM,kBAAkB,SAAuC,CAAC"}

package/lib/artefacts-policy.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.KEEP_GEN_ARTEFACTS = exports.KEEP_SPEC_ARTEFACTS = void 0;
+const node_process_1 = require("node:process");
+const raw = node_process_1.env['SF_ARTEFACTS_POLICY'];
+exports.KEEP_SPEC_ARTEFACTS = raw === 'all' || raw === 'spec';
+exports.KEEP_GEN_ARTEFACTS = raw === 'all' || raw === 'generator';

package/lib/dbml-generator/converter.d.ts

@@ -0,0 +1,5 @@
+import type { ExportFormatOption } from '@dbml/core/types/export/ModelExporter';
+export declare function convertDBMLToDatabaseModel(source: string): import("@dbml/core/types/model_structure/database").default;
+export declare function convertDBMLToJSON(source: string): import("@dbml/core/types/model_structure/database").RawDatabase;
+export declare function convertDBMLToSQL(source: string, format?: ExportFormatOption): string;
+//# sourceMappingURL=converter.d.ts.map

package/lib/dbml-generator/converter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"converter.d.ts","sourceRoot":"","sources":["../../src/dbml-generator/converter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,uCAAuC,CAAC;AAEhF,wBAAgB,0BAA0B,CAAC,MAAM,EAAE,MAAM,+DAExD;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,mEAE/C;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,GAAE,kBAA+B,UAEvF"}

package/lib/dbml-generator/converter.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.convertDBMLToDatabaseModel = convertDBMLToDatabaseModel;
+exports.convertDBMLToJSON = convertDBMLToJSON;
+exports.convertDBMLToSQL = convertDBMLToSQL;
+const core_1 = require("@dbml/core");
+function convertDBMLToDatabaseModel(source) {
+    return core_1.Parser.parse(source, 'json');
+}
+function convertDBMLToJSON(source) {
+    return core_1.Parser.parseDBMLToJSONv2(source);
+}
+function convertDBMLToSQL(source, format = 'postgres') {
+    return core_1.exporter.export(source, format);
+}

package/lib/dbml-generator/generator.d.ts

@@ -0,0 +1,4 @@
+import type { SchemaForgeRegistry } from '../schema-registry/types';
+import { DBMLGeneratorOptions, DBMLProjectScope } from './types';
+export declare function generateDBMLSpec(schemaRegistry: SchemaForgeRegistry, scopes: DBMLProjectScope[], options?: DBMLGeneratorOptions): string;
+//# sourceMappingURL=generator.d.ts.map

package/lib/dbml-generator/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/dbml-generator/generator.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AAEpE,OAAO,EAIH,oBAAoB,EAGpB,gBAAgB,EACnB,MAAM,SAAS,CAAC;AAEjB,wBAAgB,gBAAgB,CAC5B,cAAc,EAAE,mBAAmB,EACnC,MAAM,EAAE,gBAAgB,EAAE,EAC1B,OAAO,GAAE,oBAAyB,UAqFrC"}

package/lib/dbml-generator/generator.js

@@ -0,0 +1,423 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateDBMLSpec = generateDBMLSpec;
+const as_array_1 = require("@tsofist/stem/lib/as-array");
+const equal_keys_1 = require("@tsofist/stem/lib/equal-keys");
+const error_1 = require("@tsofist/stem/lib/error");
+const entries_1 = require("@tsofist/stem/lib/object/entries");
+const snake_1 = require("@tsofist/stem/lib/string/case/snake");
+const compare_1 = require("@tsofist/stem/lib/string/compare");
+const substr_1 = require("@tsofist/stem/lib/string/substr");
+const text_builder_1 = require("@tsofist/stem/lib/string/text-builder");
+function generateDBMLSpec(schemaRegistry, scopes, options = {}) {
+    const text = new text_builder_1.TextBuilder();
+    const tables = new Map();
+    const groups = new Map();
+    const sources = new Map();
+    if (options.meta?.comment) {
+        text.push(`// ${options.meta?.comment}`);
+    }
+    text.push(`Project ${options.meta?.name ?? 'Scratch'} {`);
+    text.push(`database_type: 'PostgreSQL'`, 1);
+    if (options.meta?.note) {
+        text.push(buildNote(options.meta.note), 1);
+    }
+    text.push('}');
+    text.push(``);
+    for (const scope of scopes.sort((a, b) => {
+        return (0, compare_1.compareStringsAsc)(a.scopeName ?? DefaultScopeName, b.scopeName ?? DefaultScopeName);
+    })) {
+        if (sources.has(scope.scopeName ?? DefaultScopeName)) {
+            (0, error_1.raise)(`Duplicate scope: ${scope.scopeName ?? '[ unnamed ]'}`);
+        }
+        else {
+            sources.set(scope.scopeName ?? DefaultScopeName, scope);
+        }
+    }
+    for (const { definitions, scopeName = DefaultScopeName } of sources.values()) {
+        for (const definition of definitions) {
+            const tableSpec = generateTable(definition, schemaRegistry, options);
+            if (tableSpec) {
+                if (tables.has(tableSpec.name)) {
+                    (0, error_1.raise)(`Definitions contain duplicate table name: ${tableSpec.name}`);
+                }
+                tables.set(tableSpec.name, tableSpec);
+                let groupTables = groups.get(scopeName);
+                if (!groupTables) {
+                    groupTables = [];
+                    groups.set(scopeName, groupTables);
+                }
+                groupTables.push(tableSpec.name);
+            }
+        }
+    }
+    const defaultGroupOnly = groups.size === 1 && groups.has(DefaultScopeName);
+    for (const [groupName, groupTableNames] of groups.entries()) {
+        for (const tableName of groupTableNames.sort(compare_1.compareStringsAsc)) {
+            const table = tables.get(tableName);
+            text.push(table.value);
+            text.push(``);
+        }
+        if (!defaultGroupOnly) {
+            const scope = sources.get(groupName);
+            if (scope) {
+                const comment = scope.comment;
+                if (comment) {
+                    text.push(`// ${comment}`);
+                }
+                text.push(`TableGroup ${groupName} {`);
+                for (const tableName of groupTableNames.sort(compare_1.compareStringsAsc)) {
+                    text.push(tableName, 1);
+                }
+                text.push(`}`);
+                text.push(``);
+            }
+        }
+    }
+    return text.stringify();
+}
+function generateTable(info, registry, options) {
+    const includeNotes = options?.includeNotes ?? false;
+    const entityTypeName = info.type;
+    const entitySchema = registry.getSchema(`${info.schemaId}#/definitions/${entityTypeName}`);
+    if (!entitySchema)
+        return;
+    const tableName = readDBEntityName(entitySchema);
+    if (!tableName)
+        return;
+    const { properties, required } = listProperties(entitySchema);
+    const columns = generateColumns(properties, required, includeNotes, registry, info.schemaId);
+    const indexes = generateIndexes(tableName, properties, readDBEntityIndexes(entitySchema), includeNotes, registry, info.schemaId);
+    const text = new text_builder_1.TextBuilder();
+    if (entitySchema.$comment) {
+        text.push(stringifyComment(entitySchema.$comment));
+    }
+    text.push(`Table ${tableName} {`);
+    text.push(columns, 1);
+    if (indexes.size) {
+        text.push('');
+        text.push('indexes {', 1);
+        text.push(indexes, 2);
+        text.push('}', 1);
+    }
+    if (entitySchema.description) {
+        text.push('');
+        text.push(buildNote(entitySchema.description), 1);
+    }
+    text.push('}');
+    return {
+        name: tableName,
+        value: text.stringify(),
+    };
+}
+function generateColumns(properties, requiredFields, notes, registry, schemaId) {
+    const text = new text_builder_1.TextBuilder();
+    let count = 0;
+    for (const [key, property] of (0, entries_1.entries)(properties).sort(([keyA], [keyB]) => {
+        const indexA = SortableFields.indexOf(keyA);
+        const indexB = SortableFields.indexOf(keyB);
+        if (indexA === -1 && indexB === -1)
+            return 0;
+        else if (indexA === -1)
+            return 1;
+        else if (indexB === -1)
+            return -1;
+        return indexA - indexB;
+    })) {
+        if (property === undefined)
+            continue;
+        const isRequired = requiredFields.includes(key);
+        const isColumnNullable = isNullable(property);
+        const columnType = getType(property, schemaId, registry);
+        const attributes = generateColumnAttributes(key, property, isRequired, isColumnNullable, notes);
+        if (property.$comment)
+            text.push(stringifyComment(property.$comment));
+        text.push(`${(0, snake_1.snakeCase)(key)} ${columnType} [${attributes.stringify(', ')}]`);
+        count++;
+    }
+    if (count === 0) {
+        // todo!
+        // raise(`Table ${schemaId} has no columns`);
+    }
+    return text;
+}
+function generateColumnAttributes(_key, property, isRequired, isColumnNullable, notes) {
+    const result = new text_builder_1.TextBuilder();
+    const isPK = property.dbColumn?.pk ?? false;
+    if (isPK) {
+        result.push('pk');
+    }
+    const defaultValue = property.default;
+    const hasDefaultValue = defaultValue !== undefined;
+    if (isColumnNullable && isRequired) {
+        if (!hasDefaultValue)
+            result.push('default: null');
+        // result.push('null'); <- by default
+    }
+    else if (isColumnNullable || !isRequired) {
+        result.push('null');
+    }
+    else {
+        result.push('not null');
+    }
+    if (hasDefaultValue) {
+        const v = typeof defaultValue === 'string' &&
+            defaultValue[0] !== '`' &&
+            defaultValue[defaultValue.length - 1] !== '`'
+            ? `"${defaultValue}"`
+            : defaultValue;
+        result.push(`default: ${String(v)}`);
+    }
+    if (notes && property.description) {
+        result.push(buildNote(property.description).stringify());
+    }
+    return result;
+}
+function generateIndexes(tableName, schemaProperties, entityIndexes, includeNotes, registry, schemaId) {
+    const text = new text_builder_1.TextBuilder();
+    const idx = {};
+    const normalizedTableName = tableName.replace(/\./g, '_');
+    const dropIndexes = new Set();
+    function processIndex(source, column, key, rawKey) {
+        if (!key)
+            key = column;
+        if (!rawKey)
+            rawKey = key;
+        const list = (0, as_array_1.asArray)(source);
+        for (const item of list) {
+            let indexName;
+            if (typeof item === 'string') {
+                indexName = item;
+            }
+            else if (item === true) {
+                indexName = `ix_${normalizedTableName}_${key}`;
+            }
+            else if (item != null && typeof item === 'object') {
+                if (item.name) {
+                    indexName = item.name;
+                }
+                else {
+                    const k = list.length === 1 ? key : `${key}_${item.type ?? 'btree'}`;
+                    indexName = `ix_${normalizedTableName}_${k}`;
+                }
+            }
+            if (indexName) {
+                if (item === false) {
+                    dropIndexes.add(indexName);
+                }
+                else {
+                    if (!schemaProperties[column])
+                        (0, error_1.raise)('`Column ${column} not found in schema`');
+                    const field = (0, substr_1.substr)(rawKey, '.');
+                    const index = (idx[indexName] ||= {
+                        ...(typeof item === 'object' ? item : {}),
+                        columnType: getType(schemaProperties[column], schemaId, registry),
+                        columns: [],
+                        fields: [],
+                    });
+                    if (field)
+                        index.fields.push(field);
+                    index.columns.push(column);
+                }
+            }
+        }
+    }
+    if (entityIndexes) {
+        for (const [key, def] of Object.entries(entityIndexes)) {
+            const prefix = (0, substr_1.substr)(key, 0, '.');
+            const column = prefix ? prefix : key;
+            processIndex(
+            //
+            def, column, prefix ? key.replace(/\./g, '_') : key, key);
+        }
+    }
+    for (const [column, property] of Object.entries(schemaProperties)) {
+        if (property?.dbIndex !== undefined) {
+            processIndex(property.dbIndex, column);
+        }
+    }
+    for (const [indexName, index] of (0, entries_1.entries)(idx)) {
+        if (!index)
+            continue;
+        const { columns, unique, pk, comment, note } = index;
+        if (columns.length !== new Set(columns).size) {
+            console.error(`Duplicate columns in index ${indexName} for table ${tableName}`);
+        }
+        const options = [`name: "${indexName}"`];
+        const type = index.type || index.columnType === 'jsonb' || index.columnType.endsWith('[]')
+            ? 'gin'
+            : undefined;
+        if (type)
+            options.push(`type: ${type}`);
+        if (pk)
+            options.push(`pk`);
+        if (!pk && unique)
+            options.push('unique');
+        // todo
+        // if (includeNotes && fields.length) {
+        //     options.push(`note: 'Fields: ${fields.join(', ')};'`);
+        // }
+        if (includeNotes && note)
+            options.push(buildNote(note).stringify());
+        if (comment)
+            text.push(`// ${comment}`);
+        text.push(`(${columns.map(snake_1.snakeCase).join(', ')}) [${options.join(', ')}]`);
+    }
+    return text;
+}
+function readDBEntityName({ dbEntity }) {
+    if (dbEntity) {
+        if (typeof dbEntity === 'string')
+            return dbEntity;
+        if (dbEntity.name)
+            return dbEntity.name;
+    }
+    return undefined;
+}
+function readDBEntityIndexes({ dbEntity }) {
+    if (dbEntity != null && typeof dbEntity === 'object') {
+        return dbEntity.indexes;
+    }
+    return undefined;
+}
+function stringifyComment(value) {
+    if (!value)
+        return undefined;
+    return value.split('\n').map((item) => `// ${item.trim()}`);
+}
+function buildNote(value) {
+    const result = new text_builder_1.TextBuilder();
+    if (value) {
+        if (value.includes('\n')) {
+            result.push(`note:`);
+            result.push([`'''`, ...value.split('\n'), `'''`], 1);
+        }
+        else {
+            result.push(`note: "${value}"`);
+        }
+    }
+    return result;
+}
+function isNullable(property) {
+    return (property.anyOf?.some((item) => typeof item !== 'boolean' && item?.type !== 'null') ?? false);
+}
+function getType(property, schemaId, registry) {
+    if (property.dbColumn?.type)
+        return property.dbColumn.type;
+    let type = property.type;
+    if (property.$ref) {
+        const schema = registry.getSchema(`${schemaId}${property.$ref}`);
+        if (schema && schema.type)
+            type = schema.type;
+        const ref = schema?.$ref || property.$ref;
+        if (typeof ref !== 'string')
+            (0, error_1.raise)(`Invalid schema reference type ${typeof ref} (expected string)`);
+        const refType = ref.split('/').pop();
+        if (refType && refType in {}) {
+            // @1ts-expect-error It's OK
+            // return TypeMappings[refType];
+            return '-'; // TODO!
+        }
+        else if (schema) {
+            property = schema;
+        }
+    }
+    if (typeof type !== 'string')
+        (0, error_1.raise)(`Invalid schema type ${typeof type} (expected string)`);
+    const variants = property.anyOf || property.oneOf;
+    if (variants) {
+        const nonNullType = variants.find((item) => typeof item !== 'boolean' && item?.type !== 'null');
+        if (nonNullType) {
+            return typeof nonNullType === 'object'
+                ? getType(nonNullType, schemaId, registry)
+                : nonNullType.toString();
+        }
+    }
+    if (type === 'string') {
+        if (property.format === 'date-time') {
+            return 'timestamptz';
+        }
+        return property.format === 'uuid' ? 'uuid' : 'text';
+    }
+    if (type === 'object' || type === 'array') {
+        return 'jsonb';
+    }
+    return type ?? 'jsonb';
+}
+function listProperties(schema) {
+    if (schema.properties) {
+        return {
+            type: 'object',
+            properties: schema.properties,
+            required: schema.required || [],
+        };
+    }
+    // todo oneOf
+    if (!schema.anyOf) {
+        return {
+            type: 'object',
+            properties: {},
+            required: [],
+        };
+    }
+    const propertiesMap = {};
+    const requiredSet = new Set();
+    const initialized = false;
+    for (const item of schema.anyOf) {
+        if (typeof item !== 'object')
+            continue;
+        if (item.type !== 'object')
+            continue;
+        if (typeof item.properties !== 'object')
+            continue;
+        if (!initialized) {
+            for (const name of Object.keys(item.properties)) {
+                propertiesMap[name] = item.properties[name];
+            }
+            for (const name of item.required || []) {
+                requiredSet.add(name);
+            }
+        }
+        else {
+            if (!(0, equal_keys_1.isEqualKeys)(propertiesMap, item.properties)) {
+                console.error('Properties are not identical across all members of anyOf');
+            }
+            for (const name of item.required || []) {
+                if (!requiredSet.has(name)) {
+                    console.error('Required fields are not identical across all members of anyOf');
+                }
+            }
+        }
+    }
+    return {
+        type: 'object',
+        properties: propertiesMap,
+        required: Array.from(requiredSet),
+    };
+}
+const DefaultScopeName = 'Default';
+// todo REMOVE THIS
+const SortableFields = [
+    'uid',
+    'slug',
+    'system',
+    'created',
+    'updated',
+    'deleted',
+    'position',
+    'priority',
+    'creator',
+    'active',
+    'name',
+    'kind',
+    'validity',
+    'location',
+    'visual',
+    'integration',
+    'refs',
+    'seo',
+    'contacts',
+    'content',
+];
+// todo escape notes!
+// todo escape comments!

package/lib/dbml-generator/generator.spec.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=generator.spec.d.ts.map

package/lib/dbml-generator/generator.spec.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.spec.d.ts","sourceRoot":"","sources":["../../src/dbml-generator/generator.spec.ts"],"names":[],"mappings":""}

package/lib/dbml-generator/generator.spec.js

@@ -0,0 +1,94 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const promises_1 = require("node:fs/promises");
+const noop_1 = require("@tsofist/stem/lib/noop");
+const artefacts_policy_1 = require("../artefacts-policy");
+const types_1 = require("../definition-info/types");
+const forge_1 = require("../schema-generator/forge");
+const loader_1 = require("../schema-registry/loader");
+const registry_1 = require("../schema-registry/registry");
+const generator_1 = require("./generator");
+describe('DBML Generator', () => {
+    const outputSchemaFile = './dbml.c1.generated.schema.tmp.json';
+    const outputSchemaMetadataFile = './dbml.c1.generated.definitions.tmp.json';
+    const schemaId = 'test-dbml';
+    let forgeSchemaResult;
+    let registry;
+    beforeAll(async () => {
+        forgeSchemaResult = await (0, forge_1.forgeSchema)({
+            allowUseFallbackDescription: false,
+            explicitPublic: true,
+            schemaId,
+            tsconfigFrom: './tsconfig.build-test.json',
+            sourcesDirectoryPattern: 'test-sources/dbml/c1',
+            sourcesFilesPattern: ['service.api.ts', '*.api.ts', 'types.ts'],
+            outputSchemaFile,
+            outputSchemaMetadataFile,
+        });
+        registry = (0, registry_1.createSchemaForgeRegistry)();
+        const schema = await (0, loader_1.loadJSONSchema)([outputSchemaFile]);
+        registry.addSchema(schema);
+    }, 10_000);
+    afterAll(async () => {
+        if (!artefacts_policy_1.KEEP_SPEC_ARTEFACTS) {
+            await (0, promises_1.unlink)(outputSchemaFile).catch(noop_1.noop);
+            await (0, promises_1.unlink)(outputSchemaMetadataFile).catch(noop_1.noop);
+        }
+    });
+    it('generated schema should be valid', () => {
+        expect(forgeSchemaResult).toBeTruthy();
+        expect(forgeSchemaResult.schema.$id).toStrictEqual(schemaId);
+        expect(forgeSchemaResult.generatedTemporaryFiles.length).toStrictEqual(1);
+        expect(forgeSchemaResult.refs.length).toStrictEqual(13);
+    });
+    it('basic cases', () => {
+        const definitions = registry.listDefinitions((info, keywords) => {
+            return (info.name.endsWith('Basic') &&
+                info.kind === types_1.SchemaDefinitionInfoKind.Type &&
+                keywords.has('dbEntity'));
+        });
+        const dbml = (0, generator_1.generateDBMLSpec)(registry, [
+            {
+                scopeName: 'TestScope',
+                comment: 'Test comment for TestScope',
+                schemaId,
+                definitions,
+            },
+        ], {
+            meta: {
+                name: 'TestProject',
+                comment: 'Test comment!',
+                note: [
+                    //
+                    'Multi-line note',
+                    '',
+                    '> Powered by [SchemaForge]',
+                ].join('\n'),
+            },
+            includeNotes: true,
+        });
+        expect(dbml).toMatchSnapshot();
+    });
+    it('table meta cases', () => {
+        const definitions = registry.listDefinitions((info, keywords) => {
+            return (info.name.endsWith('TableMeta') &&
+                info.kind === types_1.SchemaDefinitionInfoKind.Type &&
+                keywords.has('dbEntity'));
+        });
+        const dbml = (0, generator_1.generateDBMLSpec)(
+        //
+        registry, [{ schemaId, definitions }], { includeNotes: true });
+        expect(dbml).toMatchSnapshot();
+    });
+    it('index meta cases', () => {
+        const definitions = registry.listDefinitions((info, keywords) => {
+            return (info.name.endsWith('IndexMeta') &&
+                info.kind === types_1.SchemaDefinitionInfoKind.Type &&
+                keywords.has('dbEntity'));
+        });
+        const dbml = (0, generator_1.generateDBMLSpec)(
+        //
+        registry, [{ schemaId, definitions }], { includeNotes: true });
+        expect(dbml).toMatchSnapshot();
+    });
+});