tsondb 0.20.9 → 0.21.0

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,13 +304,14 @@ 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/renderers/ts/render.d.ts

@@ -27,6 +27,15 @@ export type TypeScriptRendererOptions = {
      */
     inferTranslationParameters?: {
         format: "mf2";
+        /**
+         * The default type to use for translation parameters when the type cannot be inferred from the message string.
+         * @default "string"
+         */
+        defaultTranslationParameterType?: "string" | "StringableTranslationParameter";
     };
+    /**
+     * The generated type to use for Date types. The data is always stored as a string, but Date can be helpful if you need to differenciate between a string and a date in code. Defaults to `string`.
+     */
+    dateType: "string" | "Date";
 };
 export declare const render: (options: Partial<TypeScriptRendererOptions> | undefined, declarations: readonly Decl[]) => string;

package/dist/src/node/renderers/ts/render.js

@@ -22,7 +22,9 @@ const defaultOptions = {
     preserveFiles: false,
     generateHelpers: {},
     addIdentifierToEntities: false,
+    dateType: "string",
 };
+const defaultTranslationParameterType = "string";
 const renderDocumentation = (comment, isDeprecated) => syntax `${comment === undefined
     ? ""
     : syntax `/**
@@ -55,7 +57,7 @@ const renderObjectType = (options, type) => {
         .map(([name, config]) => syntax `${renderDocumentation(config.comment, config.isDeprecated)}${name}${config.isRequired ? "" : "?"}: ${renderType(options, config.type)}`), Object.values(type.properties).some(prop => prop.comment !== undefined) ? EOL + EOL : EOL));
 };
 const renderBooleanType = (_options, _type) => syntax `boolean`;
-const renderDateType = (_options, _type) => syntax `Date`;
+const renderDateType = (options, _type) => options.dateType === "Date" ? syntax `Date` : syntax `string`;
 const renderFloatType = (_options, _type) => syntax `number`;
 const renderIntegerType = (_options, _type) => syntax `number`;
 const renderStringType = (_options, _type) => syntax `string`;
@@ -75,7 +77,7 @@ const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.va
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
 const renderChildEntitiesType = () => syntax `never`;
-const mapTypeNameToType = (typeName) => {
+const mapTypeNameToType = (options, typeName) => {
     switch (typeName) {
         case "string":
             return "string";
@@ -88,7 +90,8 @@ const mapTypeNameToType = (typeName) => {
             return "Date";
         case null:
         default:
-            return "StringableTranslationParameter";
+            return (options.inferTranslationParameters?.defaultTranslationParameterType ??
+                defaultTranslationParameterType);
     }
 };
 const renderTranslationParameterBrand = (options, params) => {
@@ -102,7 +105,7 @@ const renderTranslationParameterBrand = (options, params) => {
     return syntax ` & { __params: { ${entries.map(([name, type]) => `"${name}": ${type}`).join("; ")} } }`;
 };
 const renderTranslationObjectType = (options, type) => {
-    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}${renderTranslationParameterBrand(options, mapParameterTypeNames(extractParameterTypeNamesFromMessage(name), mapTypeNameToType))}`), EOL));
+    return wrapAsObject(options, combineSyntaxes(Object.entries(type.properties).map(([name, config]) => syntax `"${name.replace('"', '\\"')}"${type.allKeysAreRequired ? "" : "?"}: ${renderType(options, getTypeOfKey(config, type))}${renderTranslationParameterBrand(options, mapParameterTypeNames(extractParameterTypeNamesFromMessage(name), typeName => mapTypeNameToType(options, typeName)))}`), EOL));
 };
 const renderType = (options, type) => {
     switch (type.kind) {
@@ -187,7 +190,10 @@ const renderEntityMapType = (options, declarations) => renderMapHelperType(optio
 const renderChildEntityMapType = (options, declarations) => renderMapHelperType(options, declarations, "childEntityMap", "ChildEntityMap", decl => isEntityDecl(decl) && isEntityDeclWithParentReference(decl), decl => `${decl.name}: [${decl.name}, "${decl.parentReferenceKey}", ${decl.name}["${decl.parentReferenceKey}"]]`);
 const renderEnumMapType = (options, declarations) => renderMapHelperType(options, declarations, "enumMap", "EnumMap", isEnumDecl);
 const renderTypeAliasMapType = (options, declarations) => renderMapHelperType(options, declarations, "typeAliasMap", "TypeAliasMap", isTypeAliasDecl);
-const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2"
+const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2" &&
+    (options.inferTranslationParameters.defaultTranslationParameterType === undefined ||
+        options.inferTranslationParameters.defaultTranslationParameterType ===
+            "StringableTranslationParameter")
     ? "export type StringableTranslationParameter = {" +
         EOL +
         prefixLines(getIndentation(options.indentation, 1), "toString(): string") +

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.9",
+  "version": "0.21.0",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",