@carlonicora/nextjs-jsonapi 1.111.2 → 1.112.1

package/scripts/generate-web-module/types/field-mapping.types.ts

@@ -16,6 +16,8 @@ export const JSON_TO_TS_TYPE: Record<string, string> = {
   boolean: "boolean",
   date: "Date",
   any: "any",
+  // Rich-text BlockNote content hydrates into a block array (typed as any).
+  blocknote: "any",
 };
 
 /**
@@ -27,6 +29,8 @@ export const JSON_TO_ZOD_BASE: Record<string, string> = {
   boolean: "z.boolean()",
   date: "z.date()",
   any: "z.any()",
+  // BlockNote content is free-form; validated as any.
+  blocknote: "z.any()",
 };
 
 /**
@@ -98,6 +102,10 @@ export function getZodBase(jsonType: string): string {
  * Get form component for a field
  */
 export function getFormComponent(fieldName: string, fieldType: string): FormComponentType {
+  // Any field explicitly typed "blocknote" is a rich-text editor, regardless of name.
+  if (fieldType === "blocknote") {
+    return "BlockNoteEditor";
+  }
   // Check for special field names first, but only if the type is compatible
   // (e.g., "content" as a string field should NOT use BlockNoteEditor)
   if (SPECIAL_FIELD_COMPONENTS[fieldName]) {
@@ -113,11 +121,16 @@ export function getFormComponent(fieldName: string, fieldType: string): FormComp
 }
 
 /**
- * Check if a field indicates BlockNoteEditor should be used.
- * Only fields named "content" with non-primitive types (not string/number/boolean/date)
- * are treated as rich-content (JSON/BlockNote) fields.
+ * Check if a field indicates BlockNoteEditor should be used (rich-text content
+ * persisted as stringified JSON, hydrated into a block array).
+ *
+ * Two ways to flag a field as rich-text:
+ *  - Explicit type "blocknote" — any field name, supports multiple per module.
+ *  - Legacy: a field literally named "content" with a non-primitive type.
  */
 export function isContentField(fieldName: string, fieldType?: string): boolean {
+  // Explicit BlockNote type — the canonical, multi-field marker.
+  if (fieldType === "blocknote") return true;
   if (fieldName !== "content") return false;
   // If no type provided, assume it's a content field (backwards compat)
   if (!fieldType) return true;

package/scripts/generate-web-module/utils/i18n-updater.ts

@@ -68,44 +68,40 @@ export function updateI18n(
     entitiesUpdated = true;
   }
 
-  // Check if module already exists in features
-  const featuresAlreadyExist = messages.features && messages.features[lowercaseModuleName];
-
-  if (featuresAlreadyExist) {
-    // Features exist, but we may have added entities
-    if (entitiesUpdated) {
-      if (dryRun) {
-        return {
-          success: true,
-          message: `[DRY RUN] Module ${names.camelCase} exists, would add entities.${lowercasePluralKey}`,
-          alreadyExists: true,
-        };
+  // Additively merge this module's feature keys (fields / relationships /
+  // sections), FILLING missing keys without overwriting existing translations.
+  // Handles a brand-new module AND an existing-but-incomplete block (e.g. one
+  // first generated before its fields were known — which previously stayed an
+  // empty `{ fields: {}, relationships: {} }` skeleton forever).
+  const mergeMissing = (target: Record<string, any>, source: Record<string, any>): Record<string, any> => {
+    const out = target && typeof target === "object" && !Array.isArray(target) ? { ...target } : {};
+    for (const k of Object.keys(source)) {
+      const v = source[k];
+      if (v && typeof v === "object" && !Array.isArray(v)) {
+        out[k] = mergeMissing(out[k], v);
+      } else if (out[k] === undefined) {
+        out[k] = v;
       }
-
-      // Write updated content (entities were added)
-      const updatedContent = JSON.stringify(messages, null, 2);
-      fs.writeFileSync(messagesPath, updatedContent, "utf-8");
-
-      return {
-        success: true,
-        message: `Module ${names.camelCase} exists, added entities.${lowercasePluralKey}`,
-        alreadyExists: true,
-      };
     }
+    return out;
+  };
+
+  if (!messages.features) {
+    messages.features = {};
+  }
+  const moduleBlock = moduleMessages.features[i18nKeys.moduleName];
+  const beforeFeatures = JSON.stringify(messages.features[lowercaseModuleName] ?? null);
+  messages.features[lowercaseModuleName] = mergeMissing(messages.features[lowercaseModuleName], moduleBlock);
+  const featuresUpdated = JSON.stringify(messages.features[lowercaseModuleName]) !== beforeFeatures;
 
+  if (!entitiesUpdated && !featuresUpdated) {
     return {
       success: true,
-      message: `Module ${names.camelCase} already exists in messages/${language}.json`,
+      message: `Module ${names.camelCase} already up to date in messages/${language}.json`,
       alreadyExists: true,
     };
   }
 
-  // Add to features section (new module)
-  if (!messages.features) {
-    messages.features = {};
-  }
-  messages.features[lowercaseModuleName] = moduleMessages.features[i18nKeys.moduleName];
-
   if (dryRun) {
     return {
       success: true,
@@ -113,7 +109,6 @@ export function updateI18n(
     };
   }
 
-  // Write updated content with proper formatting
   const updatedContent = JSON.stringify(messages, null, 2);
   fs.writeFileSync(messagesPath, updatedContent, "utf-8");
 

package/scripts/generate-web-module/validators/json-schema-validator.ts

@@ -106,8 +106,9 @@ export function validateJsonSchema(schema: any): ValidationError[] {
         });
       }
 
-      // Validate known types
-      const validTypes = ["string", "number", "boolean", "date", "any"];
+      // Validate known types (mirrors the backend CypherType set plus the
+      // frontend-facing "blocknote" rich-text marker)
+      const validTypes = ["string", "number", "boolean", "date", "datetime", "json", "any", "blocknote"];
       if (field.type && !validTypes.includes(field.type)) {
         errors.push({
           field: `fields[${index}].type`,