@twin.org/ts-to-schema 0.0.1-next.9 → 0.0.2-next.1

package/dist/cjs/index.cjs

@@ -5,6 +5,7 @@ var node_url = require('node:url');
 var cliCore = require('@twin.org/cli-core');
 var promises = require('node:fs/promises');
 var core = require('@twin.org/core');
+var toolsCore = require('@twin.org/tools-core');
 var tsJsonSchemaGenerator = require('ts-json-schema-generator');
 
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
@@ -76,15 +77,33 @@ async function tsToSchema(config, outputFolder, workingDirectory) {
     await promises.writeFile(path.join(workingDirectory, "tsconfig.json"), JSON.stringify({
         compilerOptions: {}
     }, undefined, "\t"));
-    cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-schema.progress.generatingSchemas"));
-    const schemas = await generateSchemas(config.sources, config.types, workingDirectory);
     cliCore.CLIDisplay.break();
     cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-schema.progress.writingSchemas"));
-    for (const type of config.types) {
-        if (core.Is.empty(schemas[type])) {
-            throw new core.GeneralError("commands", "commands.ts-to-schema.schemaNotFound", { type });
+    for (const typeSource of config.types) {
+        const typeSourceParts = typeSource.split("/");
+        const type = core.StringHelper.pascalCase(typeSourceParts[typeSourceParts.length - 1].replace(/(\.d)?\.ts$/, ""), false);
+        let schemaObject;
+        if (core.Is.object(config.overrides?.[type])) {
+            cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-schema.progress.overridingSchema"));
+            schemaObject = config.overrides?.[type];
         }
-        let content = JSON.stringify(schemas[type], undefined, "\t");
+        else {
+            cliCore.CLIDisplay.task(core.I18n.formatMessage("commands.ts-to-schema.progress.generatingSchema"));
+            const autoExpandTypes = config.autoExpandTypes ?? [];
+            const defaultExpandTypes = ["ObjectOrArray<.*>"];
+            for (const defaultType of defaultExpandTypes) {
+                if (!autoExpandTypes.includes(defaultType)) {
+                    autoExpandTypes.push(defaultType);
+                }
+            }
+            const schemas = await generateSchemas(typeSource, type, autoExpandTypes, workingDirectory);
+            if (core.Is.empty(schemas[type])) {
+                throw new core.GeneralError("commands", "commands.ts-to-schema.schemaNotFound", { type });
+            }
+            schemaObject = schemas[type];
+        }
+        schemaObject = finaliseSchema(schemaObject, config.baseUrl, type);
+        let content = JSON.stringify(schemaObject, undefined, "\t");
         if (core.Is.objectValue(config.externalReferences)) {
             for (const external in config.externalReferences) {
                 content = content.replace(new RegExp(`#/definitions/${external}`, "g"), config.externalReferences[external]);
@@ -96,128 +115,56 @@ async function tsToSchema(config, outputFolder, workingDirectory) {
         content = content.replace(/#\/definitions\/I?([A-Z].*)/g, `${config.baseUrl}$1`);
         const filename = path.join(outputFolder, `${core.StringHelper.stripPrefix(type)}.json`);
         cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.ts-to-schema.progress.writingSchema"), filename, 1);
-        await promises.writeFile(filename, content);
+        await promises.writeFile(filename, `${content}\n`);
     }
 }
 /**
  * Generate schemas for the models.
  * @param modelDirWildcards The filenames for all the models.
  * @param types The types of the schema objects.
+ * @param autoExpandTypes The types to automatically expand.
  * @param outputWorkingDir The working directory.
  * @returns Nothing.
  * @internal
  */
-async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
+async function generateSchemas(typeSource, type, autoExpandTypes, outputWorkingDir) {
     const allSchemas = {};
-    const arraySingularTypes = [];
-    for (const type of types) {
-        if (type.endsWith("[]")) {
-            const singularType = type.slice(0, -2);
-            arraySingularTypes.push(singularType);
-            if (!types.includes(singularType)) {
-                types.push(singularType);
-            }
-        }
-    }
-    for (const files of modelDirWildcards) {
-        cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.ts-to-schema.progress.models"), files.replace(/\\/g, "/"), 1);
-        const generator = tsJsonSchemaGenerator.createGenerator({
-            path: files.replace(/\\/g, "/"),
-            type: "*",
-            tsconfig: path.join(outputWorkingDir, "tsconfig.json"),
-            skipTypeCheck: true,
-            expose: "all"
-        });
-        const schema = generator.createSchema("*");
-        if (schema.definitions) {
-            for (const def in schema.definitions) {
-                // Remove the partial markers
-                let defSub = def.replace(/^Partial<(.*?)>/g, "$1");
-                // Cleanup the generic markers
-                defSub = defSub.replace(/</g, "%3C").replace(/>/g, "%3E");
-                allSchemas[defSub] = schema.definitions[def];
-            }
+    cliCore.CLIDisplay.value(core.I18n.formatMessage("commands.ts-to-schema.progress.models"), typeSource, 1);
+    const generator = tsJsonSchemaGenerator.createGenerator({
+        path: typeSource,
+        type,
+        tsconfig: path.join(outputWorkingDir, "tsconfig.json"),
+        skipTypeCheck: true,
+        expose: "all"
+    });
+    const schema = generator.createSchema("*");
+    if (schema.definitions) {
+        for (const def in schema.definitions) {
+            const defSub = toolsCore.JsonSchemaHelper.normaliseTypeName(def);
+            allSchemas[defSub] = schema.definitions[def];
         }
     }
     const referencedSchemas = {};
-    extractTypes(allSchemas, types, referencedSchemas);
-    for (const arraySingularType of arraySingularTypes) {
-        referencedSchemas[`${arraySingularType}[]`] = {
-            type: "array",
-            items: {
-                $ref: `#/components/schemas/${arraySingularType}`
-            }
-        };
-    }
+    toolsCore.JsonSchemaHelper.extractTypes(allSchemas, [type, ...autoExpandTypes], referencedSchemas);
+    toolsCore.JsonSchemaHelper.expandTypes(referencedSchemas, autoExpandTypes);
     return referencedSchemas;
 }
 /**
- * Extract the required types from all the known schemas.
- * @param allSchemas All the known schemas.
- * @param requiredTypes The required types.
- * @param referencedSchemas The references schemas.
- * @internal
- */
-function extractTypes(allSchemas, requiredTypes, referencedSchemas) {
-    for (const type of requiredTypes) {
-        if (allSchemas[type] && !referencedSchemas[type]) {
-            referencedSchemas[type] = allSchemas[type];
-            extractTypesFromSchema(allSchemas, allSchemas[type], referencedSchemas);
-        }
-    }
-}
-/**
- * Extract type from properties definition.
- * @param allTypes All the known types.
- * @param schema The schema to extract from.
- * @param output The output types.
- * @internal
+ * Process the schema object to ensure it has the correct properties.
+ * @param schemaObject The schema object to process.
+ * @param baseUrl The base URL for the schema references.
+ * @param type The type of the schema object.
+ * @returns The finalised schema object.
  */
-function extractTypesFromSchema(allTypes, schema, output) {
-    const additionalTypes = [];
-    if (core.Is.stringValue(schema.$ref)) {
-        additionalTypes.push(schema.$ref.replace("#/definitions/", "").replace(/^Partial%3C(.*?)%3E/g, "$1"));
-    }
-    else if (core.Is.object(schema.items)) {
-        if (core.Is.arrayValue(schema.items)) {
-            for (const itemSchema of schema.items) {
-                extractTypesFromSchema(allTypes, itemSchema, output);
-            }
-        }
-        else {
-            extractTypesFromSchema(allTypes, schema.items, output);
-        }
-    }
-    else if (core.Is.object(schema.properties) || core.Is.object(schema.additionalProperties)) {
-        if (core.Is.object(schema.properties)) {
-            for (const prop in schema.properties) {
-                const p = schema.properties[prop];
-                if (core.Is.object(p)) {
-                    extractTypesFromSchema(allTypes, p, output);
-                }
-            }
-        }
-        if (core.Is.object(schema.additionalProperties)) {
-            extractTypesFromSchema(allTypes, schema.additionalProperties, output);
-        }
-    }
-    else if (core.Is.arrayValue(schema.anyOf)) {
-        for (const prop of schema.anyOf) {
-            if (core.Is.object(prop)) {
-                extractTypesFromSchema(allTypes, prop, output);
-            }
-        }
-    }
-    else if (core.Is.arrayValue(schema.oneOf)) {
-        for (const prop of schema.oneOf) {
-            if (core.Is.object(prop)) {
-                extractTypesFromSchema(allTypes, prop, output);
-            }
-        }
-    }
-    if (additionalTypes.length > 0) {
-        extractTypes(allTypes, additionalTypes, output);
-    }
+function finaliseSchema(schemaObject, baseUrl, type) {
+    toolsCore.JsonSchemaHelper.processArrays(schemaObject);
+    const { description, ...rest } = schemaObject;
+    return {
+        $schema: toolsCore.JsonSchemaHelper.SCHEMA_VERSION,
+        $id: `${baseUrl}${core.StringHelper.stripPrefix(type)}`,
+        description,
+        ...rest
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -238,7 +185,7 @@ class CLI extends cliCore.CLIBase {
         return this.execute({
             title: "TWIN TypeScript To Schema",
             appName: "ts-to-schema",
-            version: "0.0.1-next.9",
+            version: "0.0.2-next.1", // x-release-please-version
             icon: "⚙️ ",
             supportsEnvFiles: false,
             overrideOutputWidth: options?.overrideOutputWidth

package/dist/esm/index.mjs

@@ -3,6 +3,7 @@ import { fileURLToPath } from 'node:url';
 import { CLIDisplay, CLIUtils, CLIBase } from '@twin.org/cli-core';
 import { mkdir, rm, writeFile } from 'node:fs/promises';
 import { I18n, GeneralError, Is, StringHelper } from '@twin.org/core';
+import { JsonSchemaHelper } from '@twin.org/tools-core';
 import { createGenerator } from 'ts-json-schema-generator';
 
 // Copyright 2024 IOTA Stiftung.
@@ -73,15 +74,33 @@ async function tsToSchema(config, outputFolder, workingDirectory) {
     await writeFile(path.join(workingDirectory, "tsconfig.json"), JSON.stringify({
         compilerOptions: {}
     }, undefined, "\t"));
-    CLIDisplay.task(I18n.formatMessage("commands.ts-to-schema.progress.generatingSchemas"));
-    const schemas = await generateSchemas(config.sources, config.types, workingDirectory);
     CLIDisplay.break();
     CLIDisplay.task(I18n.formatMessage("commands.ts-to-schema.progress.writingSchemas"));
-    for (const type of config.types) {
-        if (Is.empty(schemas[type])) {
-            throw new GeneralError("commands", "commands.ts-to-schema.schemaNotFound", { type });
+    for (const typeSource of config.types) {
+        const typeSourceParts = typeSource.split("/");
+        const type = StringHelper.pascalCase(typeSourceParts[typeSourceParts.length - 1].replace(/(\.d)?\.ts$/, ""), false);
+        let schemaObject;
+        if (Is.object(config.overrides?.[type])) {
+            CLIDisplay.task(I18n.formatMessage("commands.ts-to-schema.progress.overridingSchema"));
+            schemaObject = config.overrides?.[type];
         }
-        let content = JSON.stringify(schemas[type], undefined, "\t");
+        else {
+            CLIDisplay.task(I18n.formatMessage("commands.ts-to-schema.progress.generatingSchema"));
+            const autoExpandTypes = config.autoExpandTypes ?? [];
+            const defaultExpandTypes = ["ObjectOrArray<.*>"];
+            for (const defaultType of defaultExpandTypes) {
+                if (!autoExpandTypes.includes(defaultType)) {
+                    autoExpandTypes.push(defaultType);
+                }
+            }
+            const schemas = await generateSchemas(typeSource, type, autoExpandTypes, workingDirectory);
+            if (Is.empty(schemas[type])) {
+                throw new GeneralError("commands", "commands.ts-to-schema.schemaNotFound", { type });
+            }
+            schemaObject = schemas[type];
+        }
+        schemaObject = finaliseSchema(schemaObject, config.baseUrl, type);
+        let content = JSON.stringify(schemaObject, undefined, "\t");
         if (Is.objectValue(config.externalReferences)) {
             for (const external in config.externalReferences) {
                 content = content.replace(new RegExp(`#/definitions/${external}`, "g"), config.externalReferences[external]);
@@ -93,128 +112,56 @@ async function tsToSchema(config, outputFolder, workingDirectory) {
         content = content.replace(/#\/definitions\/I?([A-Z].*)/g, `${config.baseUrl}$1`);
         const filename = path.join(outputFolder, `${StringHelper.stripPrefix(type)}.json`);
         CLIDisplay.value(I18n.formatMessage("commands.ts-to-schema.progress.writingSchema"), filename, 1);
-        await writeFile(filename, content);
+        await writeFile(filename, `${content}\n`);
     }
 }
 /**
  * Generate schemas for the models.
  * @param modelDirWildcards The filenames for all the models.
  * @param types The types of the schema objects.
+ * @param autoExpandTypes The types to automatically expand.
  * @param outputWorkingDir The working directory.
  * @returns Nothing.
  * @internal
  */
-async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
+async function generateSchemas(typeSource, type, autoExpandTypes, outputWorkingDir) {
     const allSchemas = {};
-    const arraySingularTypes = [];
-    for (const type of types) {
-        if (type.endsWith("[]")) {
-            const singularType = type.slice(0, -2);
-            arraySingularTypes.push(singularType);
-            if (!types.includes(singularType)) {
-                types.push(singularType);
-            }
-        }
-    }
-    for (const files of modelDirWildcards) {
-        CLIDisplay.value(I18n.formatMessage("commands.ts-to-schema.progress.models"), files.replace(/\\/g, "/"), 1);
-        const generator = createGenerator({
-            path: files.replace(/\\/g, "/"),
-            type: "*",
-            tsconfig: path.join(outputWorkingDir, "tsconfig.json"),
-            skipTypeCheck: true,
-            expose: "all"
-        });
-        const schema = generator.createSchema("*");
-        if (schema.definitions) {
-            for (const def in schema.definitions) {
-                // Remove the partial markers
-                let defSub = def.replace(/^Partial<(.*?)>/g, "$1");
-                // Cleanup the generic markers
-                defSub = defSub.replace(/</g, "%3C").replace(/>/g, "%3E");
-                allSchemas[defSub] = schema.definitions[def];
-            }
+    CLIDisplay.value(I18n.formatMessage("commands.ts-to-schema.progress.models"), typeSource, 1);
+    const generator = createGenerator({
+        path: typeSource,
+        type,
+        tsconfig: path.join(outputWorkingDir, "tsconfig.json"),
+        skipTypeCheck: true,
+        expose: "all"
+    });
+    const schema = generator.createSchema("*");
+    if (schema.definitions) {
+        for (const def in schema.definitions) {
+            const defSub = JsonSchemaHelper.normaliseTypeName(def);
+            allSchemas[defSub] = schema.definitions[def];
         }
     }
     const referencedSchemas = {};
-    extractTypes(allSchemas, types, referencedSchemas);
-    for (const arraySingularType of arraySingularTypes) {
-        referencedSchemas[`${arraySingularType}[]`] = {
-            type: "array",
-            items: {
-                $ref: `#/components/schemas/${arraySingularType}`
-            }
-        };
-    }
+    JsonSchemaHelper.extractTypes(allSchemas, [type, ...autoExpandTypes], referencedSchemas);
+    JsonSchemaHelper.expandTypes(referencedSchemas, autoExpandTypes);
     return referencedSchemas;
 }
 /**
- * Extract the required types from all the known schemas.
- * @param allSchemas All the known schemas.
- * @param requiredTypes The required types.
- * @param referencedSchemas The references schemas.
- * @internal
- */
-function extractTypes(allSchemas, requiredTypes, referencedSchemas) {
-    for (const type of requiredTypes) {
-        if (allSchemas[type] && !referencedSchemas[type]) {
-            referencedSchemas[type] = allSchemas[type];
-            extractTypesFromSchema(allSchemas, allSchemas[type], referencedSchemas);
-        }
-    }
-}
-/**
- * Extract type from properties definition.
- * @param allTypes All the known types.
- * @param schema The schema to extract from.
- * @param output The output types.
- * @internal
+ * Process the schema object to ensure it has the correct properties.
+ * @param schemaObject The schema object to process.
+ * @param baseUrl The base URL for the schema references.
+ * @param type The type of the schema object.
+ * @returns The finalised schema object.
  */
-function extractTypesFromSchema(allTypes, schema, output) {
-    const additionalTypes = [];
-    if (Is.stringValue(schema.$ref)) {
-        additionalTypes.push(schema.$ref.replace("#/definitions/", "").replace(/^Partial%3C(.*?)%3E/g, "$1"));
-    }
-    else if (Is.object(schema.items)) {
-        if (Is.arrayValue(schema.items)) {
-            for (const itemSchema of schema.items) {
-                extractTypesFromSchema(allTypes, itemSchema, output);
-            }
-        }
-        else {
-            extractTypesFromSchema(allTypes, schema.items, output);
-        }
-    }
-    else if (Is.object(schema.properties) || Is.object(schema.additionalProperties)) {
-        if (Is.object(schema.properties)) {
-            for (const prop in schema.properties) {
-                const p = schema.properties[prop];
-                if (Is.object(p)) {
-                    extractTypesFromSchema(allTypes, p, output);
-                }
-            }
-        }
-        if (Is.object(schema.additionalProperties)) {
-            extractTypesFromSchema(allTypes, schema.additionalProperties, output);
-        }
-    }
-    else if (Is.arrayValue(schema.anyOf)) {
-        for (const prop of schema.anyOf) {
-            if (Is.object(prop)) {
-                extractTypesFromSchema(allTypes, prop, output);
-            }
-        }
-    }
-    else if (Is.arrayValue(schema.oneOf)) {
-        for (const prop of schema.oneOf) {
-            if (Is.object(prop)) {
-                extractTypesFromSchema(allTypes, prop, output);
-            }
-        }
-    }
-    if (additionalTypes.length > 0) {
-        extractTypes(allTypes, additionalTypes, output);
-    }
+function finaliseSchema(schemaObject, baseUrl, type) {
+    JsonSchemaHelper.processArrays(schemaObject);
+    const { description, ...rest } = schemaObject;
+    return {
+        $schema: JsonSchemaHelper.SCHEMA_VERSION,
+        $id: `${baseUrl}${StringHelper.stripPrefix(type)}`,
+        description,
+        ...rest
+    };
 }
 
 // Copyright 2024 IOTA Stiftung.
@@ -235,7 +182,7 @@ class CLI extends CLIBase {
         return this.execute({
             title: "TWIN TypeScript To Schema",
             appName: "ts-to-schema",
-            version: "0.0.1-next.9",
+            version: "0.0.2-next.1", // x-release-please-version
             icon: "⚙️ ",
             supportsEnvFiles: false,
             overrideOutputWidth: options?.overrideOutputWidth