tsondb 0.20.8 → 0.20.10

package/dist/src/node/bin/tsondb.js

@@ -153,7 +153,10 @@ else {
             const db = await createDB(config, config.validationOptions, true);
             if (passedArguments.command.options?.check === true) {
                 debug(`running command: format --check`);
-                await db.checkFormat();
+                const result = await db.checkFormat();
+                if (!result) {
+                    process.exitCode = 1;
+                }
             }
             else {
                 debug(`running command: format`);

package/dist/src/node/index.d.ts

@@ -137,7 +137,7 @@ export declare class TSONDB<T extends DefaultTSONDBTypes = DefaultTSONDBTypes> {
     /**
      * Checks if the data on disk is formatted according to the current in-memory representation.
      */
-    checkFormat(): Promise<void>;
+    checkFormat(): Promise<boolean>;
     /**
      * Reloads the data from disk into memory.
      */

package/dist/src/node/index.js

@@ -294,6 +294,7 @@ export class TSONDB {
     async checkFormat() {
         debug("Check database formatting ...");
         let counter = 0;
+        let total = 0;
         await this.#data.forEachInstance(async (entityName, instance) => {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             const entity = this.#schema.getEntity(entityName);
@@ -303,14 +304,17 @@ export class TSONDB {
                 console.log(`Instance ${styleText("yellow", instance.id)} of entity ${styleText("cyan", entityName)} is not formatted correctly.`);
                 counter++;
             }
+            total++;
         }, true);
         if (counter === 0) {
-            console.log(styleText("green", "All data is formatted"));
+            console.log(styleText("green", `All ${total.toFixed()} instance${total === 1 ? "" : "s"} are formatted correctly`));
+            return true;
         }
         else {
-            console.error(styleText("red", `${counter.toFixed()} formatting error${counter === 1 ? "" : "s"} found`, {
+            console.error(styleText("red", `${counter.toFixed()} instance${counter === 1 ? "" : "s"} of ${total.toFixed()} instance${total === 1 ? "" : "s"} are not formatted correctly`, {
                 stream: stderr,
             }));
+            return false;
         }
     }
     /**

package/dist/src/node/schema/treeOperations/format.d.ts

@@ -3,4 +3,4 @@ import type { Type } from "../dsl/index.ts";
 /**
  * Format the structure of a value to always look the same when serialized as JSON.
  */
-export declare const formatValue: (type: Type, value: unknown, options: Partial<FormatterOptions> | undefined) => unknown;
+export declare const formatValue: (type: Type, value: unknown, typeArguments: Record<string, Type>, options: Partial<FormatterOptions> | undefined) => unknown;

package/dist/src/node/schema/treeOperations/format.js

@@ -9,24 +9,56 @@ const formatTranslationObjectValue = (type, value) => typeof value === "object"
         type[key] ? formatTranslationObjectValue(type[key], item) : item,
     ])), Object.keys(type))
     : value;
+const resolveNestedTypeArguments = (type, typeArguments) => {
+    switch (type.kind) {
+        case NodeKind.TypeArgumentType:
+            return typeArguments[type.argument.name] ?? type;
+        case NodeKind.IncludeIdentifierType:
+            return {
+                ...type,
+                args: type.args.map(arg => resolveNestedTypeArguments(arg, typeArguments)),
+            };
+        case NodeKind.ArrayType:
+        case NodeKind.BooleanType:
+        case NodeKind.ChildEntitiesType:
+        case NodeKind.DateType:
+        case NodeKind.EnumType:
+        case NodeKind.FloatType:
+        case NodeKind.IntegerType:
+        case NodeKind.NestedEntityMapType:
+        case NodeKind.ObjectType:
+        case NodeKind.ReferenceIdentifierType:
+        case NodeKind.StringType:
+        case NodeKind.TranslationObjectType:
+            return type;
+        default:
+            return assertExhaustive(type);
+    }
+};
 /**
  * Format the structure of a value to always look the same when serialized as JSON.
  */
-export const formatValue = (type, value, options) => {
+export const formatValue = (type, value, typeArguments, options) => {
     switch (type.kind) {
         case NodeKind.ArrayType:
             return Array.isArray(value)
-                ? value.map(item => formatValue(type.items, item, options))
+                ? value.map(item => formatValue(type.items, item, typeArguments, options))
                 : value;
         case NodeKind.ObjectType:
             return typeof value === "object" && value !== null && !Array.isArray(value)
-                ? sortObjectKeysByIndex(mapObject(value, (item, key) => type.properties[key] ? formatValue(type.properties[key].type, item, options) : item), Object.keys(type.properties))
+                ? sortObjectKeysByIndex(mapObject(value, (item, key) => type.properties[key]
+                    ? formatValue(type.properties[key].type, item, typeArguments, options)
+                    : item), Object.keys(type.properties))
                 : value;
         case NodeKind.IncludeIdentifierType:
-            return formatValue(type.reference.type.value, value, options);
+            return formatValue(type.reference.type.value, value, Object.fromEntries(type.args.map((arg, index) => [
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                type.reference.parameters[index].name,
+                resolveNestedTypeArguments(arg, typeArguments),
+            ])), options);
         case NodeKind.NestedEntityMapType:
             return typeof value === "object" && value !== null && !Array.isArray(value)
-                ? sortObjectKeys(mapObject(value, item => formatValue(type.type.value, item, options)))
+                ? sortObjectKeys(mapObject(value, item => formatValue(type.type.value, item, typeArguments, options)))
                 : value;
         case NodeKind.EnumType: {
             if (typeof value === "object" &&
@@ -41,7 +73,7 @@ export const formatValue = (type, value, options) => {
                     [ENUM_DISCRIMINATOR_KEY]: caseName,
                     ...(caseValue == null || caseType == null
                         ? {}
-                        : { [caseName]: formatValue(caseType, caseValue, options) }),
+                        : { [caseName]: formatValue(caseType, caseValue, typeArguments, options) }),
                 };
             }
             return value;
@@ -65,11 +97,19 @@ export const formatValue = (type, value, options) => {
                     return value;
             }
         }
+        case NodeKind.TypeArgumentType: {
+            const typeArgument = typeArguments[type.argument.name];
+            if (typeArgument === undefined) {
+                return value;
+            }
+            else {
+                return formatValue(typeArgument, value, typeArguments, options);
+            }
+        }
         case NodeKind.BooleanType:
         case NodeKind.DateType:
         case NodeKind.FloatType:
         case NodeKind.IntegerType:
-        case NodeKind.TypeArgumentType:
         case NodeKind.ReferenceIdentifierType:
             return value;
         default:

package/dist/src/node/utils/files.js

@@ -11,4 +11,4 @@ export const writeInstance = (dataRoot, entity, id, instance, formatterOptions)
     encoding: "utf-8",
 });
 export const deleteInstance = (dataRoot, entityName, id) => rm(getPathToInstance(dataRoot, entityName, id));
-export const formatInstance = (entity, instanceContent, options) => JSON.stringify(formatValue(entity.type.value, instanceContent, options), undefined, 2) + "\n";
+export const formatInstance = (entity, instanceContent, options) => JSON.stringify(formatValue(entity.type.value, instanceContent, {}, options), undefined, 2) + "\n";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.20.8",
+  "version": "0.20.10",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",