@twin.org/ts-to-schema 0.0.1-next.8 → 0.0.1

package/dist/cjs/index.cjs

@@ -10,6 +10,7 @@ var tsJsonSchemaGenerator = require('ts-json-schema-generator');
 var _documentCurrentScript = typeof document !== 'undefined' ? document.currentScript : null;
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+const SCHEMA_VERSION = "https://json-schema.org/draft/2020-12/schema";
 /**
  * Build the root command to be consumed by the CLI.
  * @param program The command to build on.
@@ -76,24 +77,38 @@ 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 schemas = await generateSchemas(typeSource, type, 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]);
             }
         }
-        content = content.replace(/#\/definitions\/I?/g, config.baseUrl);
+        // First replace all types that start with II to a single I with the new base url
+        content = content.replace(/#\/definitions\/II(.*)/g, `${config.baseUrl}I$1`);
+        // Then other types starting with capitals (optionally interfaces starting with I)
+        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`);
     }
 }
 /**
@@ -104,48 +119,25 @@ async function tsToSchema(config, outputFolder, workingDirectory) {
  * @returns Nothing.
  * @internal
  */
-async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
+async function generateSchemas(typeSource, type, 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 = 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}`
-            }
-        };
-    }
+    extractTypes(allSchemas, [type], referencedSchemas);
     return referencedSchemas;
 }
 /**
@@ -216,6 +208,96 @@ function extractTypesFromSchema(allTypes, schema, output) {
         extractTypes(allTypes, additionalTypes, output);
     }
 }
+/**
+ * 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 finaliseSchema(schemaObject, baseUrl, type) {
+    processArrays(schemaObject);
+    const { description, ...rest } = schemaObject;
+    return {
+        $schema: SCHEMA_VERSION,
+        $id: `${baseUrl}${core.StringHelper.stripPrefix(type)}`,
+        description,
+        ...rest
+    };
+}
+/**
+ * Process arrays in the schema object.
+ * @param schemaObject The schema object to process.
+ */
+function processArrays(schemaObject) {
+    if (core.Is.object(schemaObject)) {
+        // latest specs have singular items in `items` property
+        // and multiple items in prefixItems, so update the schema accordingly
+        // https://www.learnjsonschema.com/2020-12/applicator/items/
+        // https://www.learnjsonschema.com/2020-12/applicator/prefixitems/
+        const schemaItems = schemaObject.items;
+        if (core.Is.array(schemaItems) || core.Is.object(schemaItems)) {
+            schemaObject.prefixItems = core.ArrayHelper.fromObjectOrArray(schemaItems);
+            schemaObject.items = false;
+        }
+        const additionalItems = schemaObject.additionalItems;
+        if (core.Is.array(additionalItems) || core.Is.object(additionalItems)) {
+            schemaObject.items = core.ArrayHelper.fromObjectOrArray(additionalItems)[0];
+            delete schemaObject.additionalItems;
+        }
+        processSchemaDictionary(schemaObject.properties);
+        processArrays(schemaObject.additionalProperties);
+        processSchemaArray(schemaObject.allOf);
+        processSchemaArray(schemaObject.anyOf);
+        processSchemaArray(schemaObject.oneOf);
+    }
+}
+/**
+ * Process arrays in the schema object.
+ * @param schemaDictionary The schema object to process.
+ */
+function processSchemaDictionary(schemaDictionary) {
+    if (core.Is.object(schemaDictionary)) {
+        for (const item of Object.values(schemaDictionary)) {
+            if (core.Is.object(item)) {
+                processArrays(item);
+            }
+        }
+    }
+}
+/**
+ * Process arrays in the schema object.
+ * @param schemaArray The schema object to process.
+ */
+function processSchemaArray(schemaArray) {
+    if (core.Is.arrayValue(schemaArray)) {
+        for (const item of schemaArray) {
+            if (core.Is.object(item)) {
+                processArrays(item);
+            }
+        }
+    }
+}
+/**
+ * Cleanup TypeScript markers from the type name.
+ * @param typeName The definition string to clean up.
+ * @returns The cleaned up definition string.
+ */
+function normaliseTypeName(typeName) {
+    // Remove the partial markers
+    let sTypeName = typeName.replace(/^Partial<(.*?)>/g, "$1");
+    sTypeName = sTypeName.replace(/Partial%3CI(.*?)%3E/g, "$1");
+    // Remove the omit markers
+    sTypeName = sTypeName.replace(/^Omit<(.*?),.*>/g, "$1");
+    sTypeName = sTypeName.replace(/Omit%3CI(.*?)%2C.*%3E/g, "$1");
+    // Remove the pick markers
+    sTypeName = sTypeName.replace(/^Pick<(.*?),.*>/g, "$1");
+    sTypeName = sTypeName.replace(/Pick%3CI(.*?)%2C.*%3E/g, "$1");
+    // Cleanup the generic markers
+    sTypeName = sTypeName.replace(/</g, "%3C").replace(/>/g, "%3E");
+    sTypeName = sTypeName.replace(/%3Cunknown%3E/g, "");
+    return sTypeName;
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -235,7 +317,7 @@ class CLI extends cliCore.CLIBase {
         return this.execute({
             title: "TWIN TypeScript To Schema",
             appName: "ts-to-schema",
-            version: "0.0.1-next.8",
+            version: "0.0.1", // x-release-please-version
             icon: "⚙️ ",
             supportsEnvFiles: false,
             overrideOutputWidth: options?.overrideOutputWidth

package/dist/esm/index.mjs

@@ -2,11 +2,12 @@ import path from 'node:path';
 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 { I18n, GeneralError, Is, StringHelper, ArrayHelper } from '@twin.org/core';
 import { createGenerator } from 'ts-json-schema-generator';
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
+const SCHEMA_VERSION = "https://json-schema.org/draft/2020-12/schema";
 /**
  * Build the root command to be consumed by the CLI.
  * @param program The command to build on.
@@ -73,24 +74,38 @@ 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 schemas = await generateSchemas(typeSource, type, 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]);
             }
         }
-        content = content.replace(/#\/definitions\/I?/g, config.baseUrl);
+        // First replace all types that start with II to a single I with the new base url
+        content = content.replace(/#\/definitions\/II(.*)/g, `${config.baseUrl}I$1`);
+        // Then other types starting with capitals (optionally interfaces starting with I)
+        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`);
     }
 }
 /**
@@ -101,48 +116,25 @@ async function tsToSchema(config, outputFolder, workingDirectory) {
  * @returns Nothing.
  * @internal
  */
-async function generateSchemas(modelDirWildcards, types, outputWorkingDir) {
+async function generateSchemas(typeSource, type, 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 = 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}`
-            }
-        };
-    }
+    extractTypes(allSchemas, [type], referencedSchemas);
     return referencedSchemas;
 }
 /**
@@ -213,6 +205,96 @@ function extractTypesFromSchema(allTypes, schema, output) {
         extractTypes(allTypes, additionalTypes, output);
     }
 }
+/**
+ * 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 finaliseSchema(schemaObject, baseUrl, type) {
+    processArrays(schemaObject);
+    const { description, ...rest } = schemaObject;
+    return {
+        $schema: SCHEMA_VERSION,
+        $id: `${baseUrl}${StringHelper.stripPrefix(type)}`,
+        description,
+        ...rest
+    };
+}
+/**
+ * Process arrays in the schema object.
+ * @param schemaObject The schema object to process.
+ */
+function processArrays(schemaObject) {
+    if (Is.object(schemaObject)) {
+        // latest specs have singular items in `items` property
+        // and multiple items in prefixItems, so update the schema accordingly
+        // https://www.learnjsonschema.com/2020-12/applicator/items/
+        // https://www.learnjsonschema.com/2020-12/applicator/prefixitems/
+        const schemaItems = schemaObject.items;
+        if (Is.array(schemaItems) || Is.object(schemaItems)) {
+            schemaObject.prefixItems = ArrayHelper.fromObjectOrArray(schemaItems);
+            schemaObject.items = false;
+        }
+        const additionalItems = schemaObject.additionalItems;
+        if (Is.array(additionalItems) || Is.object(additionalItems)) {
+            schemaObject.items = ArrayHelper.fromObjectOrArray(additionalItems)[0];
+            delete schemaObject.additionalItems;
+        }
+        processSchemaDictionary(schemaObject.properties);
+        processArrays(schemaObject.additionalProperties);
+        processSchemaArray(schemaObject.allOf);
+        processSchemaArray(schemaObject.anyOf);
+        processSchemaArray(schemaObject.oneOf);
+    }
+}
+/**
+ * Process arrays in the schema object.
+ * @param schemaDictionary The schema object to process.
+ */
+function processSchemaDictionary(schemaDictionary) {
+    if (Is.object(schemaDictionary)) {
+        for (const item of Object.values(schemaDictionary)) {
+            if (Is.object(item)) {
+                processArrays(item);
+            }
+        }
+    }
+}
+/**
+ * Process arrays in the schema object.
+ * @param schemaArray The schema object to process.
+ */
+function processSchemaArray(schemaArray) {
+    if (Is.arrayValue(schemaArray)) {
+        for (const item of schemaArray) {
+            if (Is.object(item)) {
+                processArrays(item);
+            }
+        }
+    }
+}
+/**
+ * Cleanup TypeScript markers from the type name.
+ * @param typeName The definition string to clean up.
+ * @returns The cleaned up definition string.
+ */
+function normaliseTypeName(typeName) {
+    // Remove the partial markers
+    let sTypeName = typeName.replace(/^Partial<(.*?)>/g, "$1");
+    sTypeName = sTypeName.replace(/Partial%3CI(.*?)%3E/g, "$1");
+    // Remove the omit markers
+    sTypeName = sTypeName.replace(/^Omit<(.*?),.*>/g, "$1");
+    sTypeName = sTypeName.replace(/Omit%3CI(.*?)%2C.*%3E/g, "$1");
+    // Remove the pick markers
+    sTypeName = sTypeName.replace(/^Pick<(.*?),.*>/g, "$1");
+    sTypeName = sTypeName.replace(/Pick%3CI(.*?)%2C.*%3E/g, "$1");
+    // Cleanup the generic markers
+    sTypeName = sTypeName.replace(/</g, "%3C").replace(/>/g, "%3E");
+    sTypeName = sTypeName.replace(/%3Cunknown%3E/g, "");
+    return sTypeName;
+}
 
 // Copyright 2024 IOTA Stiftung.
 // SPDX-License-Identifier: Apache-2.0.
@@ -232,7 +314,7 @@ class CLI extends CLIBase {
         return this.execute({
             title: "TWIN TypeScript To Schema",
             appName: "ts-to-schema",
-            version: "0.0.1-next.8",
+            version: "0.0.1", // x-release-please-version
             icon: "⚙️ ",
             supportsEnvFiles: false,
             overrideOutputWidth: options?.overrideOutputWidth