tsondb 0.12.7 → 0.12.8

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

@@ -5,5 +5,11 @@ export type TypeScriptRendererOptions = {
     preserveFiles: boolean;
     generateEntityMapType: boolean;
     addIdentifierToEntities: boolean;
+    /**
+     * Infer translation parameter types from the message strings in a {@link TranslationObjectType TranslationObject} as branded types.
+     */
+    inferTranslationParameters?: {
+        format: "mf2";
+    };
 };
 export declare const render: (options: Partial<TypeScriptRendererOptions> | undefined, declarations: readonly Decl[]) => string;

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

@@ -3,6 +3,7 @@ import { dirname, relative } from "node:path";
 import { discriminatorKey } from "../../../shared/enum.js";
 import { unique } from "../../../shared/utils/array.js";
 import { toCamelCase } from "../../../shared/utils/string.js";
+import { extractParameterTypeNamesFromMessage, mapParameterTypeNames, } from "../../../shared/utils/translation.js";
 import { assertExhaustive } from "../../../shared/utils/typeSafety.js";
 import { asDecl } from "../../schema/declarations/Declaration.js";
 import { addEphemeralUUIDToType, createEntityIdentifierTypeAsDecl, isEntityDecl, } from "../../schema/declarations/EntityDecl.js";
@@ -14,7 +15,7 @@ import { getTypeOfKey } from "../../schema/types/generic/TranslationObjectType.j
 import { isNestedEntityMapType } from "../../schema/types/references/NestedEntityMapType.js";
 import { ReferenceIdentifierType } from "../../schema/types/references/ReferenceIdentifierType.js";
 import { ensureSpecialDirStart } from "../../utils/path.js";
-import { combineSyntaxes, emptyRenderResult, indent, prefixLines, syntax, } from "../../utils/render.js";
+import { combineSyntaxes, emptyRenderResult, getIndentation, indent, prefixLines, syntax, } from "../../utils/render.js";
 const defaultOptions = {
     indentation: 2,
     objectTypeKeyword: "interface",
@@ -62,8 +63,34 @@ const renderEnumType = (options, type) => combineSyntaxes(Object.entries(type.va
     ? ""
     : syntax `${EOL}${caseName}: ${renderType(options, caseDef.type)}`}`)}${EOL}}`)));
 const renderChildEntitiesType = (options, type) => renderType(options, ArrayType(ReferenceIdentifierType(type.entity), { uniqueItems: true }));
+const mapTypeNameToType = (typeName) => {
+    switch (typeName) {
+        case "string":
+            return "string";
+        case "number":
+        case "integer":
+            return "number";
+        case "date":
+        case "datetime":
+        case "time":
+            return "Date";
+        case null:
+        default:
+            return "StringableTranslationParameter";
+    }
+};
+const renderTranslationParameterBrand = (options, params) => {
+    if (options.inferTranslationParameters === undefined) {
+        return emptyRenderResult;
+    }
+    const entries = Object.entries(params);
+    if (entries.length === 0) {
+        return emptyRenderResult;
+    }
+    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))}`), 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), mapTypeNameToType))}`), EOL));
 };
 const renderType = (options, type) => {
     switch (type.kind) {
@@ -135,6 +162,11 @@ const renderEntityMapType = (options, declarations) => syntax `export type Entit
     .filter(isEntityDecl)
     .sort((a, b) => a.name.localeCompare(b.name))
     .map(decl => syntax `${decl.name}: ${decl.name}`), EOL))}${EOL}}${EOL + EOL}`;
+const renderStringableTranslationParameterType = (options) => options.inferTranslationParameters?.format === "mf2"
+    ? "export type StringableTranslationParameter = {\n" +
+        prefixLines(getIndentation(options.indentation, 1), "toString(): string") +
+        "\n}\n\n"
+    : "";
 export const render = (options = defaultOptions, declarations) => {
     const finalOptions = { ...defaultOptions, ...options };
     const [_, entityMap] = finalOptions.generateEntityMapType
@@ -154,6 +186,7 @@ export const render = (options = defaultOptions, declarations) => {
         return undefined;
     }, declarations));
     return (entityMap +
+        renderStringableTranslationParameterType(finalOptions) +
         (finalOptions.preserveFiles
             ? (declarations[0] === undefined ? "" : renderImports(declarations[0].sourceUrl, imports)) +
                 content

package/dist/src/node/schema/Schema.js

@@ -20,6 +20,13 @@ const checkDuplicateIdentifier = (existingDecls, decl) => {
         throw new Error(`Duplicate declaration name "${decl.name}" in "${decl.sourceUrl}" and "${existingDeclWithSameName.sourceUrl}". Make sure declaration names are globally unique.`);
     }
 };
+// const checkReservedIdentifier = (decl: NestedDecl) => {
+//   if (RESERVED_DECLARATION_IDENTIFIER.includes(decl.name)) {
+//     throw new Error(
+//       `Declaration "${decl.name}" in "${decl.sourceUrl}" uses a reserved identifier name.`,
+//     )
+//   }
+// }
 const checkParameterNamesShadowing = (decls) => {
     for (const decl of decls) {
         for (const param of getParameterNames(decl)) {
@@ -219,9 +226,10 @@ export const Schema = (declarations, localeEntity) => {
     debug("collecting nested declarations ...");
     const allDecls = addDeclarations([], localeEntity ? declarations.concat(localeEntity) : declarations);
     debug("found %d nested declarations", allDecls.length);
-    debug("checking for duplicate identifiers ...");
+    debug("checking for duplicate identifiers ..."); // debug("checking for duplicate or reserved identifiers ...")
     allDecls.forEach((decl, declIndex) => {
         checkDuplicateIdentifier(allDecls.slice(0, declIndex), decl);
+        // checkReservedIdentifier(decl)
     });
     const allDeclsWithoutNestedEntities = allDecls.filter(decl => decl.kind !== "NestedEntity");
     debug("checking name shadowing ...");

package/dist/src/node/utils/render.d.ts

@@ -7,4 +7,5 @@ export type RenderResult = [imports: {
 export declare const emptyRenderResult: RenderResult;
 export declare const combineSyntaxes: (syntaxes: (RenderResult | string | undefined)[], separator?: string) => RenderResult;
 export declare const syntax: (strings: TemplateStringsArray, ...values: (RenderResult | string | undefined)[]) => RenderResult;
+export declare const getIndentation: (spaces: number, indentLevel: number) => string;
 export declare const indent: (spaces: number, indentLevel: number, text: RenderResult) => RenderResult;

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

@@ -28,7 +28,8 @@ export const syntax = (strings, ...values) => strings.reduce((acc, str, i) => {
         return [acc[0], acc[1] + str.replace(/\n/g, EOL)];
     }
 }, emptyRenderResult);
+export const getIndentation = (spaces, indentLevel) => " ".repeat(spaces * indentLevel);
 export const indent = (spaces, indentLevel, text) => [
     text[0],
-    prefixLines(" ".repeat(spaces * indentLevel), text[1]),
+    prefixLines(getIndentation(spaces, indentLevel), text[1]),
 ];

package/dist/src/shared/utils/translation.d.ts

@@ -0,0 +1,2 @@
+export declare const extractParameterTypeNamesFromMessage: (message: string) => Record<string, string | null>;
+export declare const mapParameterTypeNames: <T>(typeMap: Record<string, string | null>, map: (typeName: string | null) => T) => Record<string, T>;

package/dist/src/shared/utils/translation.js

@@ -0,0 +1,66 @@
+import { MessageError, parseMessage } from "messageformat";
+import { assertExhaustive } from "./typeSafety.js";
+const mergeAssoc = (acc, key, value) => {
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- if there is a previous value and the current result is null, keep the more specific one
+    return { ...acc, [key]: value ?? acc[key] };
+};
+const reduceMapAssoc = (map, acc, item) => {
+    const result = map(item);
+    if (result) {
+        return mergeAssoc(acc, result[0], result[1]);
+    }
+    return acc;
+};
+const reduceADT = (cases, acc, item) => {
+    const caseFn = cases[item.type];
+    return caseFn?.(acc, item) ?? acc;
+};
+const extractParameterFromDeclaration = (decl) => {
+    switch (decl.type) {
+        case "input":
+            return [decl.name, decl.value.functionRef?.name ?? null];
+        case "local":
+            return undefined;
+        default:
+            return assertExhaustive(decl);
+    }
+};
+const extractParametersFromDeclarations = (decls) => decls.reduce((acc, decl) => reduceMapAssoc(extractParameterFromDeclaration, acc, decl), {});
+const reduceParametersFromPattern = (acc, pattern) => pattern.reduce((acc, element) => {
+    if (typeof element === "string") {
+        return acc;
+    }
+    return reduceADT({
+        expression: (acc, element) => {
+            if (!element.arg) {
+                return acc;
+            }
+            return reduceADT({
+                variable: (acc, variable) => mergeAssoc(acc, variable.name, element.functionRef?.name ?? null),
+            }, acc, element.arg);
+        },
+    }, acc, element);
+}, acc);
+export const extractParameterTypeNamesFromMessage = (message) => {
+    try {
+        const dataModel = parseMessage(message);
+        switch (dataModel.type) {
+            case "message":
+                return reduceParametersFromPattern(extractParametersFromDeclarations(dataModel.declarations), dataModel.pattern);
+            case "select": {
+                return dataModel.selectors.reduce((acc, variable) => mergeAssoc(acc, variable.name, null), dataModel.variants.reduce((acc, variant) => reduceParametersFromPattern(acc, variant.value), extractParametersFromDeclarations(dataModel.declarations)));
+            }
+            default:
+                return assertExhaustive(dataModel);
+        }
+    }
+    catch (error) {
+        if (error instanceof MessageError) {
+            throw new MessageError(error.message, message);
+        }
+        else {
+            throw error;
+        }
+    }
+};
+export const mapParameterTypeNames = (typeMap, map) => Object.fromEntries(Object.entries(typeMap).map(([key, typeName]) => [key, map(typeName)]));

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tsondb",
-  "version": "0.12.7",
+  "version": "0.12.8",
   "description": "",
   "license": "ISC",
   "author": "Lukas Obermann",
@@ -50,6 +50,7 @@
     "@preact/signals": "^2.5.1",
     "debug": "^4.4.3",
     "express": "^5.1.0",
+    "messageformat": "^4.0.0",
     "preact": "^10.27.2",
     "preact-iso": "^2.11.0",
     "simple-cli-args": "^0.1.3",