@tsofist/schema-forge 3.2.0 → 3.3.0

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

@@ -1 +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"}
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../src/dbml-generator/generator.ts"],"names":[],"mappings":"AAgBA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,0BAA0B,CAAC;AACpE,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,UAsGrC"}

package/lib/dbml-generator/generator.js

@@ -9,17 +9,21 @@ 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");
+const cache_1 = require("../schema-dereference/cache");
+const dereference_1 = require("../schema-dereference/dereference");
 function generateDBMLSpec(schemaRegistry, scopes, options = {}) {
     const text = new text_builder_1.TextBuilder();
     const tables = new Map();
     const groups = new Map();
     const sources = new Map();
+    const dereferencedRootSchemas = 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('');
         text.push(buildNote(options.meta.note), 1);
     }
     text.push('}');
@@ -34,9 +38,21 @@ function generateDBMLSpec(schemaRegistry, scopes, options = {}) {
             sources.set(scope.scopeName ?? DefaultScopeName, scope);
         }
     }
-    for (const { definitions, scopeName = DefaultScopeName } of sources.values()) {
+    for (const { definitions, scopeName = DefaultScopeName, schemaId } of sources.values()) {
+        let dereferencedRootSchema = dereferencedRootSchemas.get(schemaId);
+        if (!dereferencedRootSchemas.has(schemaId)) {
+            const root = schemaRegistry.getRootSchema(schemaId) ||
+                (0, error_1.raise)(`Root schema ${schemaId} not found`);
+            dereferencedRootSchema =
+                (0, dereference_1.dereferenceSchema)(root, {
+                    throwOnDereferenceFailure: true,
+                    sharedCacheStorage: DereferenceSchemaCache ||
+                        (DereferenceSchemaCache = (0, cache_1.createSchemaDereferenceSharedCache)()),
+                }) || (0, error_1.raise)(`Failed to dereference root schema for ${schemaId}`);
+            dereferencedRootSchemas.set(schemaId, dereferencedRootSchema);
+        }
         for (const definition of definitions) {
-            const tableSpec = generateTable(definition, schemaRegistry, options);
+            const tableSpec = generateTable(definition, options, dereferencedRootSchema);
             if (tableSpec) {
                 if (tables.has(tableSpec.name)) {
                     (0, error_1.raise)(`Definitions contain duplicate table name: ${tableSpec.name}`);
@@ -76,18 +92,20 @@ function generateDBMLSpec(schemaRegistry, scopes, options = {}) {
     }
     return text.stringify();
 }
-function generateTable(info, registry, options) {
-    const includeNotes = options?.includeNotes ?? false;
+function generateTable(info, options, dereferencedRootSchema) {
+    const includeNotes = options.includeNotes ?? false;
     const entityTypeName = info.type;
-    const entitySchema = registry.getSchema(`${info.schemaId}#/definitions/${entityTypeName}`);
+    const entitySchema = (dereferencedRootSchema.definitions || dereferencedRootSchema.$defs)?.[entityTypeName];
     if (!entitySchema)
         return;
+    if (typeof entitySchema !== 'object')
+        (0, error_1.raise)(`Invalid definition type for table: ${typeof entitySchema} (expected object)`);
     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 columns = generateColumns(properties, required, includeNotes, info.schemaId, tableName);
+    const indexes = generateIndexes(tableName, properties, readDBEntityIndexes(entitySchema), includeNotes, info.schemaId);
     const text = new text_builder_1.TextBuilder();
     if (entitySchema.$comment) {
         text.push(stringifyComment(entitySchema.$comment));
@@ -110,7 +128,7 @@ function generateTable(info, registry, options) {
         value: text.stringify(),
     };
 }
-function generateColumns(properties, requiredFields, notes, registry, schemaId) {
+function generateColumns(properties, requiredFields, notes, schemaId, tableName) {
     const text = new text_builder_1.TextBuilder();
     let count = 0;
     for (const [key, property] of (0, entries_1.entries)(properties).sort(([keyA], [keyB]) => {
@@ -128,16 +146,18 @@ function generateColumns(properties, requiredFields, notes, registry, schemaId)
             continue;
         const isRequired = requiredFields.includes(key);
         const isColumnNullable = isNullable(property);
-        const columnType = getType(property, schemaId, registry);
+        const columnType = getDBType(property, schemaId);
         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(', ')}]`);
+        const attributesText = attributes.stringify(', ');
+        const hasLineBreak = attributesText.includes('\n');
+        text.push(`${(0, snake_1.snakeCase)(key)} ${columnType} [${attributesText}${hasLineBreak ? '\n' : ']'}`);
+        hasLineBreak && text.push(']');
         count++;
     }
     if (count === 0) {
-        // todo!
-        // raise(`Table ${schemaId} has no columns`);
+        (0, error_1.raise)(`Table ${tableName} (${schemaId}) does not have any columns defined`);
     }
     return text;
 }
@@ -169,11 +189,11 @@ function generateColumnAttributes(_key, property, isRequired, isColumnNullable,
         result.push(`default: ${String(v)}`);
     }
     if (notes && property.description) {
-        result.push(buildNote(property.description).stringify());
+        result.push(buildNote(property.description, 2).stringify());
     }
     return result;
 }
-function generateIndexes(tableName, schemaProperties, entityIndexes, includeNotes, registry, schemaId) {
+function generateIndexes(tableName, schemaProperties, entityIndexes, includeNotes, schemaId) {
     const text = new text_builder_1.TextBuilder();
     const idx = {};
     const normalizedTableName = tableName.replace(/\./g, '_');
@@ -211,7 +231,7 @@ function generateIndexes(tableName, schemaProperties, entityIndexes, includeNote
                     const field = (0, substr_1.substr)(rawKey, '.');
                     const index = (idx[indexName] ||= {
                         ...(typeof item === 'object' ? item : {}),
-                        columnType: getType(schemaProperties[column], schemaId, registry),
+                        columnType: getDBType(schemaProperties[column], schemaId),
                         columns: [],
                         fields: [],
                     });
@@ -241,9 +261,9 @@ function generateIndexes(tableName, schemaProperties, entityIndexes, includeNote
             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}`);
+            console.warn(`Duplicate columns in index ${indexName} for table ${tableName}`);
         }
-        const options = [`name: "${indexName}"`];
+        const options = new text_builder_1.TextBuilder(`name: "${indexName}"`);
         const type = index.type || index.columnType === 'jsonb' || index.columnType.endsWith('[]')
             ? 'gin'
             : undefined;
@@ -253,15 +273,15 @@ function generateIndexes(tableName, schemaProperties, entityIndexes, includeNote
             options.push(`pk`);
         if (!pk && unique)
             options.push('unique');
-        // todo
+        // todo?
         // if (includeNotes && fields.length) {
         //     options.push(`note: 'Fields: ${fields.join(', ')};'`);
         // }
         if (includeNotes && note)
-            options.push(buildNote(note).stringify());
+            options.push(buildNote(note, 3).stringify());
         if (comment)
             text.push(`// ${comment}`);
-        text.push(`(${columns.map(snake_1.snakeCase).join(', ')}) [${options.join(', ')}]`);
+        text.push(`(${columns.map(snake_1.snakeCase).join(', ')}) [${options.stringify(', ')}]`);
     }
     return text;
 }
@@ -285,12 +305,12 @@ function stringifyComment(value) {
         return undefined;
     return value.split('\n').map((item) => `// ${item.trim()}`);
 }
-function buildNote(value) {
+function buildNote(value, mlLevel = 1) {
     const result = new text_builder_1.TextBuilder();
     if (value) {
         if (value.includes('\n')) {
             result.push(`note:`);
-            result.push([`'''`, ...value.split('\n'), `'''`], 1);
+            result.push([`'''`, ...value.split('\n'), `'''`], mlLevel);
         }
         else {
             result.push(`note: "${value}"`);
@@ -301,35 +321,26 @@ function buildNote(value) {
 function isNullable(property) {
     return (property.anyOf?.some((item) => typeof item !== 'boolean' && item?.type !== 'null') ?? false);
 }
-function getType(property, schemaId, registry) {
+let DereferenceSchemaCache;
+function getDBType(property, schemaId) {
     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 (!type && property.$ref) {
+        (0, error_1.raise)(`Type ${JSON.stringify(property)} (${schemaId}) was not dereferenced`);
+    }
+    if (type && Array.isArray(type)) {
+        type = type.filter((item) => item !== 'null')[0];
+    }
+    if (type && typeof type !== 'string') {
+        (0, error_1.raise)(`Invalid SchemaTypeName value type (${typeof type}) (expected string)`);
     }
-    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)
+                ? getDBType(nonNullType, schemaId)
                 : nonNullType.toString();
         }
     }
@@ -352,7 +363,10 @@ function listProperties(schema) {
             required: schema.required || [],
         };
     }
-    // todo oneOf
+    if (schema.oneOf) {
+        // todo oneOf
+        (0, error_1.raise)(`Schema ${JSON.stringify(schema)} has oneOf, but not implemented yet`);
+    }
     if (!schema.anyOf) {
         return {
             type: 'object',
@@ -380,11 +394,11 @@ function listProperties(schema) {
         }
         else {
             if (!(0, equal_keys_1.isEqualKeys)(propertiesMap, item.properties)) {
-                console.error('Properties are not identical across all members of anyOf');
+                console.warn('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');
+                    console.warn('Required fields are not identical across all members of anyOf');
                 }
             }
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tsofist/schema-forge",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "Generate JSON schema from TypeScript types",
   "author": "Andrew Berdnikov <tsofistgudmen@gmail.com>",
   "license": "LGPL-3.0",