@carlonicora/nextjs-jsonapi 1.1.1 → 1.3.0

package/scripts/generate-web-module/templates/data/index.ts

@@ -0,0 +1,10 @@
+/**
+ * Data Layer Templates Index
+ *
+ * Re-exports all data layer template generators.
+ */
+
+export * from "./interface.template";
+export * from "./model.template";
+export * from "./service.template";
+export * from "./fields.template";

package/scripts/generate-web-module/templates/data/interface.template.ts

@@ -0,0 +1,136 @@
+/**
+ * Interface Template
+ *
+ * Generates {Module}Interface.ts file with Input type and Interface definition.
+ */
+
+import { FrontendTemplateData, FrontendField, FrontendRelationship } from "../../types/template-data.interface";
+import { toCamelCase, pluralize } from "../../transformers/name-transformer";
+
+/**
+ * Generate the interface file content
+ *
+ * @param data - Frontend template data
+ * @returns Generated file content
+ */
+export function generateInterfaceTemplate(data: FrontendTemplateData): string {
+  const { names, extendsContent, fields, relationships } = data;
+
+  const imports = generateImports(data);
+  const inputType = generateInputType(data);
+  const interfaceDefinition = generateInterface(data);
+
+  return `${imports}
+
+${inputType}
+
+${interfaceDefinition}
+`;
+}
+
+/**
+ * Generate import statements
+ */
+function generateImports(data: FrontendTemplateData): string {
+  const { extendsContent, relationships } = data;
+  const imports: string[] = [];
+
+  // Relationship interface imports
+  relationships.forEach((rel) => {
+    imports.push(
+      `import { ${rel.interfaceName} } from "${rel.interfaceImportPath}";`
+    );
+  });
+
+  // Base interface import
+  if (extendsContent) {
+    imports.push(
+      `import { ContentInput, ContentInterface } from "@/features/features/content/data/ContentInterface";`
+    );
+  } else {
+    imports.push(
+      `import { ApiDataInterface } from "@carlonicora/nextjs-jsonapi/core";`
+    );
+  }
+
+  return imports.join("\n");
+}
+
+/**
+ * Generate Input type definition
+ */
+function generateInputType(data: FrontendTemplateData): string {
+  const { names, extendsContent, fields, relationships } = data;
+
+  const fieldLines: string[] = ["  id: string;"];
+
+  // Add fields (excluding inherited ones if extending Content)
+  const fieldsToInclude = extendsContent
+    ? fields.filter((f) => !["name", "tldr", "abstract"].includes(f.name))
+    : fields;
+
+  fieldsToInclude.forEach((field) => {
+    const optional = field.nullable ? "?" : "";
+    fieldLines.push(`  ${field.name}${optional}: ${field.tsType};`);
+  });
+
+  // Add relationship IDs
+  relationships.forEach((rel) => {
+    const effectiveName = rel.variant || rel.name;
+    if (rel.single) {
+      const key = `${toCamelCase(effectiveName)}Id`;
+      const optional = rel.nullable ? "?" : "";
+      fieldLines.push(`  ${key}${optional}: string;`);
+    } else {
+      const key = `${toCamelCase(rel.name)}Ids`;
+      fieldLines.push(`  ${key}?: string[];`);
+    }
+  });
+
+  if (extendsContent) {
+    return `export type ${names.pascalCase}Input = ContentInput & {
+${fieldLines.join("\n")}
+};`;
+  } else {
+    return `export type ${names.pascalCase}Input = {
+${fieldLines.join("\n")}
+};`;
+  }
+}
+
+/**
+ * Generate interface definition
+ */
+function generateInterface(data: FrontendTemplateData): string {
+  const { names, extendsContent, fields, relationships } = data;
+
+  const getterLines: string[] = [];
+
+  // Add field getters (excluding inherited ones if extending Content)
+  const fieldsToInclude = extendsContent
+    ? fields.filter((f) => !["name", "tldr", "abstract"].includes(f.name))
+    : fields;
+
+  fieldsToInclude.forEach((field) => {
+    getterLines.push(`  get ${field.name}(): ${field.tsType};`);
+  });
+
+  // Add relationship getters
+  relationships.forEach((rel) => {
+    const effectiveName = rel.variant || rel.name;
+    if (rel.single) {
+      const propertyName = toCamelCase(effectiveName);
+      const type = rel.nullable ? `${rel.interfaceName} | undefined` : rel.interfaceName;
+      getterLines.push(`  get ${propertyName}(): ${type};`);
+    } else {
+      const propertyName = pluralize(toCamelCase(rel.name));
+      getterLines.push(`  get ${propertyName}(): ${rel.interfaceName}[];`);
+    }
+  });
+
+  const baseInterface = extendsContent ? "ContentInterface" : "ApiDataInterface";
+
+  return `export interface ${names.pascalCase}Interface extends ${baseInterface} {
+${getterLines.join("\n")}
+}`;
+}

package/scripts/generate-web-module/templates/data/model.template.ts

@@ -0,0 +1,327 @@
+/**
+ * Model Template
+ *
+ * Generates {Module}.ts class file with rehydrate and createJsonApi methods.
+ */
+
+import { FrontendTemplateData, FrontendField, FrontendRelationship } from "../../types/template-data.interface";
+import { toCamelCase, toPascalCase, pluralize } from "../../transformers/name-transformer";
+import { AUTHOR_VARIANT } from "../../types/field-mapping.types";
+
+/**
+ * Generate the model file content
+ *
+ * @param data - Frontend template data
+ * @returns Generated file content
+ */
+export function generateModelTemplate(data: FrontendTemplateData): string {
+  const { names, extendsContent, fields, relationships } = data;
+
+  const imports = generateImports(data);
+  const privateFields = generatePrivateFields(data);
+  const getters = generateGetters(data);
+  const rehydrateMethod = generateRehydrateMethod(data);
+  const createJsonApiMethod = generateCreateJsonApiMethod(data);
+
+  const baseClass = extendsContent ? "Content" : "AbstractApiData";
+
+  return `${imports}
+
+export class ${names.pascalCase} extends ${baseClass} implements ${names.pascalCase}Interface {
+${privateFields}
+
+${getters}
+
+${rehydrateMethod}
+
+${createJsonApiMethod}
+}
+`;
+}
+
+/**
+ * Generate import statements
+ */
+function generateImports(data: FrontendTemplateData): string {
+  const { names, extendsContent, relationships } = data;
+  const imports: string[] = [];
+
+  // Own interface import
+  imports.push(
+    `import { ${names.pascalCase}Input, ${names.pascalCase}Interface } from "@/features/${data.targetDir}/${names.kebabCase}/data/${names.pascalCase}Interface";`
+  );
+
+  // Relationship interface imports
+  relationships.forEach((rel) => {
+    imports.push(
+      `import { ${rel.interfaceName} } from "${rel.interfaceImportPath}";`
+    );
+  });
+
+  // Base class and core imports
+  if (extendsContent) {
+    imports.push(
+      `import { Content } from "@/features/features/content/data/Content";`
+    );
+    imports.push(
+      `import { JsonApiHydratedDataInterface, Modules } from "@carlonicora/nextjs-jsonapi/core";`
+    );
+  } else {
+    imports.push(
+      `import { AbstractApiData, JsonApiHydratedDataInterface, Modules } from "@carlonicora/nextjs-jsonapi/core";`
+    );
+  }
+
+  return imports.join("\n");
+}
+
+/**
+ * Generate private field declarations
+ */
+function generatePrivateFields(data: FrontendTemplateData): string {
+  const { fields, relationships, extendsContent } = data;
+  const lines: string[] = [];
+
+  // Field private members (excluding inherited)
+  const fieldsToInclude = extendsContent
+    ? fields.filter((f) => !["name", "tldr", "abstract"].includes(f.name))
+    : fields;
+
+  fieldsToInclude.forEach((field) => {
+    lines.push(`  private _${field.name}?: ${field.tsType};`);
+  });
+
+  // Relationship private members
+  if (!extendsContent) {
+    relationships.forEach((rel) => {
+      const effectiveName = rel.variant || rel.name;
+      if (rel.single) {
+        const propName = toCamelCase(effectiveName);
+        lines.push(`  private _${propName}?: ${rel.interfaceName};`);
+      } else {
+        const propName = pluralize(toCamelCase(rel.name));
+        lines.push(`  private _${propName}?: ${rel.interfaceName}[];`);
+      }
+    });
+  }
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate getter methods
+ */
+function generateGetters(data: FrontendTemplateData): string {
+  const { fields, relationships, extendsContent } = data;
+  const lines: string[] = [];
+
+  // Field getters (excluding inherited)
+  const fieldsToInclude = extendsContent
+    ? fields.filter((f) => !["name", "tldr", "abstract"].includes(f.name))
+    : fields;
+
+  fieldsToInclude.forEach((field) => {
+    const defaultValue = getDefaultValue(field);
+    lines.push(`  get ${field.name}(): ${field.tsType} {
+    return this._${field.name} ?? ${defaultValue};
+  }`);
+  });
+
+  // Relationship getters (only for non-Content extending)
+  if (!extendsContent) {
+    relationships.forEach((rel) => {
+      const effectiveName = rel.variant || rel.name;
+      if (rel.single) {
+        const propName = toCamelCase(effectiveName);
+        if (rel.nullable) {
+          lines.push(`  get ${propName}(): ${rel.interfaceName} | undefined {
+    return this._${propName};
+  }`);
+        } else {
+          lines.push(`  get ${propName}(): ${rel.interfaceName} {
+    if (this._${propName} === undefined) throw new Error("JsonApi error: ${data.names.camelCase} ${propName} is missing");
+    return this._${propName};
+  }`);
+        }
+      } else {
+        const propName = pluralize(toCamelCase(rel.name));
+        lines.push(`  get ${propName}(): ${rel.interfaceName}[] {
+    return this._${propName} ?? [];
+  }`);
+      }
+    });
+  }
+
+  return lines.join("\n\n");
+}
+
+/**
+ * Generate rehydrate method
+ */
+function generateRehydrateMethod(data: FrontendTemplateData): string {
+  const { names, fields, relationships, extendsContent } = data;
+  const lines: string[] = [];
+
+  lines.push(`  rehydrate(data: JsonApiHydratedDataInterface): this {`);
+  lines.push(`    super.rehydrate(data);`);
+  lines.push(``);
+
+  // Field rehydration (excluding inherited)
+  const fieldsToInclude = extendsContent
+    ? fields.filter((f) => !["name", "tldr", "abstract"].includes(f.name))
+    : fields;
+
+  fieldsToInclude.forEach((field) => {
+    if (field.isContentField || field.name === "content") {
+      // Content fields need JSON parsing
+      lines.push(
+        `    this._${field.name} = data.jsonApi.attributes.${field.name} ? JSON.parse(data.jsonApi.attributes.${field.name}) : undefined;`
+      );
+    } else if (field.type === "date") {
+      lines.push(
+        `    this._${field.name} = data.jsonApi.attributes.${field.name} ? new Date(data.jsonApi.attributes.${field.name}) : undefined;`
+      );
+    } else {
+      lines.push(
+        `    this._${field.name} = data.jsonApi.attributes.${field.name};`
+      );
+    }
+  });
+
+  // Relationship rehydration (only for non-Content)
+  if (!extendsContent && relationships.length > 0) {
+    lines.push(``);
+    relationships.forEach((rel) => {
+      const effectiveName = rel.variant || rel.name;
+      if (rel.single) {
+        const propName = toCamelCase(effectiveName);
+        const relationshipKey = effectiveName.toLowerCase();
+        lines.push(
+          `    this._${propName} = this._readIncluded(data, "${relationshipKey}", Modules.${rel.name}) as ${rel.interfaceName}${rel.nullable ? " | undefined" : ""};`
+        );
+      } else {
+        const propName = pluralize(toCamelCase(rel.name));
+        const relationshipKey = pluralize(rel.name.toLowerCase());
+        lines.push(
+          `    this._${propName} = this._readIncludedList(data, "${relationshipKey}", Modules.${rel.name}) as ${rel.interfaceName}[];`
+        );
+      }
+    });
+  }
+
+  lines.push(``);
+  lines.push(`    return this;`);
+  lines.push(`  }`);
+
+  return lines.join("\n");
+}
+
+/**
+ * Generate createJsonApi method
+ */
+function generateCreateJsonApiMethod(data: FrontendTemplateData): string {
+  const { names, fields, relationships, extendsContent } = data;
+  const lines: string[] = [];
+
+  lines.push(`  createJsonApi(data: ${names.pascalCase}Input) {`);
+  lines.push(`    const response: any = {`);
+  lines.push(`      data: {`);
+  lines.push(`        type: Modules.${names.pascalCase}.name,`);
+  lines.push(`        id: data.id,`);
+  lines.push(`        attributes: {},`);
+  lines.push(`        meta: {},`);
+  lines.push(`        relationships: {},`);
+  lines.push(`      },`);
+  lines.push(`      included: [],`);
+  lines.push(`    };`);
+  lines.push(``);
+
+  // Call super.addContentInput if extending Content
+  if (extendsContent) {
+    lines.push(`    super.addContentInput(response, data);`);
+    lines.push(``);
+  }
+
+  // Field serialization (excluding inherited)
+  const fieldsToInclude = extendsContent
+    ? fields.filter((f) => !["name", "tldr", "abstract"].includes(f.name))
+    : fields;
+
+  fieldsToInclude.forEach((field) => {
+    if (field.isContentField || field.name === "content") {
+      lines.push(
+        `    if (data.${field.name} !== undefined) response.data.attributes.${field.name} = JSON.stringify(data.${field.name});`
+      );
+    } else {
+      lines.push(
+        `    if (data.${field.name} !== undefined) response.data.attributes.${field.name} = data.${field.name};`
+      );
+    }
+  });
+
+  // Relationship serialization (skip author for Content, handle others)
+  const relationshipsToSerialize = relationships.filter(
+    (rel) => !(extendsContent && rel.variant === AUTHOR_VARIANT)
+  );
+
+  if (relationshipsToSerialize.length > 0) {
+    lines.push(``);
+    relationshipsToSerialize.forEach((rel) => {
+      const effectiveName = rel.variant || rel.name;
+      const payloadKey = rel.single
+        ? `${toCamelCase(effectiveName)}Id`
+        : `${toCamelCase(rel.name)}Ids`;
+      const relationshipKey = toCamelCase(effectiveName);
+
+      if (rel.single) {
+        lines.push(`    if (data.${payloadKey}) {`);
+        lines.push(`      response.data.relationships.${relationshipKey} = {`);
+        lines.push(`        data: {`);
+        lines.push(`          type: Modules.${rel.name}.name,`);
+        lines.push(`          id: data.${payloadKey},`);
+        lines.push(`        },`);
+        lines.push(`      };`);
+        lines.push(`    }`);
+      } else {
+        lines.push(`    if (data.${payloadKey} && data.${payloadKey}.length > 0) {`);
+        lines.push(`      response.data.relationships.${relationshipKey} = {`);
+        lines.push(`        data: data.${payloadKey}.map((id) => ({`);
+        lines.push(`          type: Modules.${rel.name}.name,`);
+        lines.push(`          id,`);
+        lines.push(`        })),`);
+        lines.push(`      };`);
+        lines.push(`    }`);
+      }
+    });
+  }
+
+  lines.push(``);
+  lines.push(`    return response;`);
+  lines.push(`  }`);
+
+  return lines.join("\n");
+}
+
+/**
+ * Get default value for a field type
+ */
+function getDefaultValue(field: FrontendField): string {
+  if (field.isContentField || field.name === "content") {
+    return "[]";
+  }
+
+  switch (field.type) {
+    case "string":
+      return '""';
+    case "number":
+      return "0";
+    case "boolean":
+      return "false";
+    case "date":
+      return "new Date()";
+    case "any":
+      return "undefined";
+    default:
+      return "undefined";
+  }
+}

package/scripts/generate-web-module/templates/data/service.template.ts

@@ -0,0 +1,185 @@
+/**
+ * Service Template
+ *
+ * Generates {Module}Service.ts class file with CRUD and relationship methods.
+ */
+
+import { FrontendTemplateData, FrontendRelationship } from "../../types/template-data.interface";
+import { toCamelCase, toPascalCase } from "../../transformers/name-transformer";
+
+/**
+ * Generate the service file content
+ *
+ * @param data - Frontend template data
+ * @returns Generated file content
+ */
+export function generateServiceTemplate(data: FrontendTemplateData): string {
+  const { names, relationships, relationshipServiceMethods } = data;
+
+  const imports = generateImports(data);
+  const findOneMethod = generateFindOneMethod(data);
+  const findManyMethod = generateFindManyMethod(data);
+  const relationshipMethods = generateRelationshipMethods(data);
+  const createMethod = generateCreateMethod(data);
+  const updateMethod = generateUpdateMethod(data);
+  const deleteMethod = generateDeleteMethod(data);
+
+  return `${imports}
+
+export class ${names.pascalCase}Service extends AbstractService {
+${findOneMethod}
+
+${findManyMethod}
+
+${relationshipMethods}
+${createMethod}
+
+${updateMethod}
+
+${deleteMethod}
+}
+`;
+}
+
+/**
+ * Generate import statements
+ */
+function generateImports(data: FrontendTemplateData): string {
+  const { names } = data;
+
+  return `import { AbstractService, HttpMethod, NextRef, PreviousRef } from "@carlonicora/nextjs-jsonapi/core";
+import { EndpointCreator } from "@carlonicora/nextjs-jsonapi/core";
+import { ${names.pascalCase}Input, ${names.pascalCase}Interface } from "@/features/${data.targetDir}/${names.kebabCase}/data/${names.pascalCase}Interface";
+import { Modules } from "@carlonicora/nextjs-jsonapi/core";`;
+}
+
+/**
+ * Generate findOne method
+ */
+function generateFindOneMethod(data: FrontendTemplateData): string {
+  const { names } = data;
+
+  return `  static async findOne(params: { id: string }): Promise<${names.pascalCase}Interface> {
+    return this.callApi<${names.pascalCase}Interface>({
+      type: Modules.${names.pascalCase},
+      method: HttpMethod.GET,
+      endpoint: new EndpointCreator({ endpoint: Modules.${names.pascalCase}, id: params.id }).generate(),
+    });
+  }`;
+}
+
+/**
+ * Generate findMany method
+ */
+function generateFindManyMethod(data: FrontendTemplateData): string {
+  const { names } = data;
+
+  return `  static async findMany(params: {
+    search?: string;
+    fetchAll?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<${names.pascalCase}Interface[]> {
+    const endpoint = new EndpointCreator({ endpoint: Modules.${names.pascalCase} });
+
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.${names.pascalCase}.inclusions?.lists?.fields) endpoint.limitToFields(Modules.${names.pascalCase}.inclusions.lists.fields);
+    if (Modules.${names.pascalCase}.inclusions?.lists?.types) endpoint.limitToType(Modules.${names.pascalCase}.inclusions.lists.types);
+
+    return this.callApi({
+      type: Modules.${names.pascalCase},
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }`;
+}
+
+/**
+ * Generate relationship query methods
+ */
+function generateRelationshipMethods(data: FrontendTemplateData): string {
+  const { names, relationshipServiceMethods } = data;
+
+  if (relationshipServiceMethods.length === 0) {
+    return "";
+  }
+
+  return relationshipServiceMethods
+    .map((method) => {
+      return `  static async ${method.methodName}(params: {
+    ${method.paramName}: string;
+    search?: string;
+    fetchAll?: boolean;
+    next?: NextRef;
+    prev?: PreviousRef;
+  }): Promise<${names.pascalCase}Interface[]> {
+    const endpoint = new EndpointCreator({
+      endpoint: Modules.${method.relationshipName},
+      id: params.${method.paramName},
+      childEndpoint: Modules.${names.pascalCase},
+    });
+
+    if (params.fetchAll) endpoint.addAdditionalParam("fetchAll", "true");
+    if (params.search) endpoint.addAdditionalParam("search", params.search);
+    if (Modules.${names.pascalCase}.inclusions?.lists?.fields) endpoint.limitToFields(Modules.${names.pascalCase}.inclusions.lists.fields);
+    if (Modules.${names.pascalCase}.inclusions?.lists?.types) endpoint.limitToType(Modules.${names.pascalCase}.inclusions.lists.types);
+
+    return this.callApi({
+      type: Modules.${names.pascalCase},
+      method: HttpMethod.GET,
+      endpoint: endpoint.generate(),
+      next: params.next,
+    });
+  }`;
+    })
+    .join("\n\n");
+}
+
+/**
+ * Generate create method
+ */
+function generateCreateMethod(data: FrontendTemplateData): string {
+  const { names } = data;
+
+  return `  static async create(params: ${names.pascalCase}Input): Promise<${names.pascalCase}Interface> {
+    return this.callApi({
+      type: Modules.${names.pascalCase},
+      method: HttpMethod.POST,
+      endpoint: new EndpointCreator({ endpoint: Modules.${names.pascalCase} }).generate(),
+      input: params,
+    });
+  }`;
+}
+
+/**
+ * Generate update method
+ */
+function generateUpdateMethod(data: FrontendTemplateData): string {
+  const { names } = data;
+
+  return `  static async update(params: ${names.pascalCase}Input): Promise<${names.pascalCase}Interface> {
+    return this.callApi({
+      type: Modules.${names.pascalCase},
+      method: HttpMethod.PUT,
+      endpoint: new EndpointCreator({ endpoint: Modules.${names.pascalCase}, id: params.id }).generate(),
+      input: params,
+    });
+  }`;
+}
+
+/**
+ * Generate delete method
+ */
+function generateDeleteMethod(data: FrontendTemplateData): string {
+  const { names } = data;
+
+  return `  static async delete(params: { ${names.camelCase}Id: string }): Promise<void> {
+    await this.callApi({
+      type: Modules.${names.pascalCase},
+      method: HttpMethod.DELETE,
+      endpoint: new EndpointCreator({ endpoint: Modules.${names.pascalCase}, id: params.${names.camelCase}Id }).generate(),
+    });
+  }`;
+}

package/scripts/generate-web-module/templates/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Templates Index
+ *
+ * Exports all template generators.
+ */
+
+// Data layer templates
+export {
+  generateInterfaceTemplate,
+  generateModelTemplate,
+  generateServiceTemplate,
+  generateFieldsTemplate,
+} from "./data";
+
+// Component templates
+export {
+  generateEditorTemplate,
+  generateDeleterTemplate,
+  generateSelectorTemplate,
+  generateMultiSelectorTemplate,
+  generateListTemplate,
+  generateDetailsTemplate,
+  generateContentTemplate,
+  generateContainerTemplate,
+  generateListContainerTemplate,
+} from "./components";
+
+// Context, hooks, module templates
+export { generateContextTemplate } from "./context.template";
+export { generateTableHookTemplate } from "./table-hook.template";
+export { generateModuleTemplate } from "./module.template";
+
+// Page templates
+export { generateListPageTemplate, generateDetailPageTemplate } from "./pages";