@team-codeme/crud-forge 0.0.0-stage → 1.0.0

package/src/validator/diagnostics.js

@@ -0,0 +1,608 @@
+const _ = require("lodash");
+const {
+  DEFAULT_AUDIT_FIELDS,
+  ACTIVE_STATUS_FIELD,
+  SUPPORTED_GDL_ANNOTATIONS,
+  SUPPORTED_JDL_ANNOTATIONS,
+} = require("../parser/jdl-parser");
+const TYPES = [
+  "String",
+  "Integer",
+  "Long",
+  "BigDecimal",
+  "Float",
+  "Double",
+  "Boolean",
+  "LocalDate",
+  "Instant",
+  "ZonedDateTime",
+  "TextBlob",
+  "UUID",
+];
+const GDL = {
+  string: "String",
+  bool: "Boolean",
+  int: "Integer",
+  long: "Long",
+  double: "Double",
+  bigDecimal: "BigDecimal",
+  date: "LocalDate",
+  datetime: "Instant",
+};
+const RESERVED = new Set(
+  "class function var let const default export import extends implements interface enum new delete return this super constructor prototype __proto__".split(
+    " ",
+  ),
+);
+
+// Keep offsets while removing comments; quoted patterns must retain their content.
+function clean(source) {
+  return source.replace(
+    /"(?:\\.|[^"\\])*"|'(?:\\.|[^'\\])*'|\/\*[\s\S]*?\*\/|\/\/[^\n]*/g,
+    (token) => (token.startsWith("/") ? token.replace(/[^\n]/g, " ") : token),
+  );
+}
+function analyzeSchema(
+  source,
+  { file = "<schema>", isGdl = false, config = {} } = {},
+) {
+  const diagnostics = [];
+  const text = clean(source);
+  const blocks = [];
+  function add(
+    code,
+    message,
+    offset = 0,
+    entity,
+    field,
+    suggestion = "Correct the schema and retry.",
+    severity = "error",
+  ) {
+    const before = text.slice(0, offset).split("\n");
+    diagnostics.push({
+      severity,
+      code,
+      file,
+      line: before.length,
+      column: before[before.length - 1].length + 1,
+      entity,
+      field,
+      message,
+      suggestion,
+    });
+  }
+  function identifier(name, offset, entity, field) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(name) || RESERVED.has(name))
+      add(
+        "invalid-name",
+        `"${name}" cannot be represented safely in generated TypeScript.`,
+        offset,
+        entity,
+        field,
+        "Use a non-reserved identifier beginning with a letter or underscore.",
+      );
+  }
+  let cursor = 0;
+  while (cursor < text.length) {
+    if (/\s/.test(text[cursor])) {
+      cursor++;
+      continue;
+    }
+    const match =
+      /^((?:@\w+\s+)*)((?:entity|enum|relationship))\s+([^\s{]+)\s*\{/.exec(
+        text.slice(cursor),
+      );
+    if (!match) {
+      add(
+        "syntax",
+        "Unrecognized declaration or unsupported directive.",
+        cursor,
+        undefined,
+        undefined,
+        "Use entity, enum, or relationship declarations; put supported annotations before entity.",
+      );
+      const end = text.indexOf("\n", cursor);
+      cursor = end < 0 ? text.length : end + 1;
+      continue;
+    }
+    const start = cursor;
+    const bodyStart = cursor + match[0].length;
+    let depth = 1;
+    let quote = null;
+    cursor = bodyStart;
+    for (; cursor < text.length; cursor++) {
+      const c = text[cursor];
+      if (quote) {
+        if (c === "\\") cursor++;
+        else if (c === quote) quote = null;
+        continue;
+      }
+      if (c === '"' || c === "'") {
+        quote = c;
+        continue;
+      }
+      if (c === "{") depth++;
+      if (c === "}" && --depth === 0) break;
+    }
+    if (depth) {
+      add(
+        "syntax",
+        "Unclosed declaration.",
+        start,
+        match[3],
+        undefined,
+        "Add the closing brace.",
+      );
+      break;
+    }
+    blocks.push({
+      kind: match[2],
+      name: match[3],
+      annotations: [...match[1].matchAll(/@(\w+)/g)].map((m) => m[1]),
+      start,
+      bodyStart,
+      body: text.slice(bodyStart, cursor),
+    });
+    cursor++;
+  }
+  const names = new Map(),
+    paths = new Map(),
+    fields = new Map();
+  const normalizedEntities = [];
+  for (const b of blocks.filter((b) => b.kind !== "relationship")) {
+    identifier(b.name, b.start, b.name);
+    if (names.has(b.name))
+      add(
+        "duplicate-name",
+        `Duplicate declaration ${b.name}.`,
+        b.start,
+        b.name,
+        undefined,
+        "Rename or remove the duplicate declaration.",
+      );
+    names.set(b.name, b);
+    const output = _.kebabCase(b.name).toLowerCase();
+    if (!output)
+      add(
+        "output-collision",
+        `${b.name} produces an empty output filename.`,
+        b.start,
+        b.name,
+        undefined,
+        "Use a name containing letters or digits.",
+      );
+    if (b.kind === "entity")
+      identifier(
+        (config.namingConventions?.modelInterfacePrefix || "I") + b.name,
+        b.start,
+        b.name,
+      );
+    if (paths.has(output) && paths.get(output) !== b.name)
+      add(
+        "output-collision",
+        `${b.name} and ${paths.get(output)} generate the same output path ${output}.`,
+        b.start,
+        b.name,
+        undefined,
+        "Use names that produce distinct kebab-case filenames.",
+      );
+    paths.set(output, b.name);
+    const supportedAnnotations = isGdl
+      ? SUPPORTED_GDL_ANNOTATIONS
+      : SUPPORTED_JDL_ANNOTATIONS;
+    for (const annotation of b.annotations)
+      if (b.kind !== "entity" || !supportedAnnotations.has(annotation))
+        add(
+          "unsupported-annotation",
+          `@${annotation} has no implemented frontend behavior. Backend support is unverified.`,
+          b.start,
+          b.name,
+          undefined,
+          "Remove the annotation or implement an explicit capability mapping before generation.",
+        );
+    if (b.kind === "enum") {
+      const values = b.body.split(",").map((v) => v.trim());
+      const seen = new Set();
+      for (const value of values) {
+        identifier(value, b.bodyStart, b.name);
+        if (seen.has(value))
+          add(
+            "duplicate-enum-value",
+            `Duplicate enum value ${value}.`,
+            b.bodyStart,
+            b.name,
+          );
+        seen.add(value);
+      }
+      continue;
+    }
+    if (!b.body.trim())
+      add(
+        "empty-entity",
+        `Entity ${b.name} has no fields.`,
+        b.start,
+        b.name,
+        undefined,
+        "Add at least one supported field.",
+      );
+    const members = new Set(["id"]);
+    const entityFields = [];
+    normalizedEntities.push({ name: b.name, fields: entityFields });
+    fields.set(b.name, members);
+    let offset = b.bodyStart;
+    for (const line of b.body.split("\n")) {
+      const value = line.trim();
+      const loc = offset + line.indexOf(value);
+      offset += line.length + 1;
+      if (!value) continue;
+      const m = /^(\S+)\s+(\S+)(.*)$/.exec(value);
+      if (!m) {
+        add(
+          "field-syntax",
+          "Malformed field declaration.",
+          loc,
+          b.name,
+          undefined,
+          "Use one field per line: type name (GDL) or name type (JDL).",
+        );
+        continue;
+      }
+      const name = isGdl ? m[2] : m[1],
+        rawType = isGdl ? m[1] : m[2],
+        type = GDL[rawType] || rawType;
+      identifier(name, loc, b.name, name);
+      if (members.has(name))
+        add(
+          "field-collision",
+          `${b.name}.${name} duplicates a field or generated id.`,
+          loc,
+          b.name,
+          name,
+          "Remove or rename the field; id is generated automatically.",
+        );
+      members.add(name);
+      // GDL accepts lowercase aliases (string/bool/…) and JDL PascalCase primitives (String/Boolean/…).
+      const knownGdlType =
+        Object.hasOwn(GDL, rawType) || TYPES.includes(rawType) || TYPES.includes(GDL[rawType]);
+      const knownJdlType = TYPES.includes(rawType);
+      if (
+        !(isGdl ? knownGdlType : knownJdlType) &&
+        names.get(rawType)?.kind !== "enum" &&
+        !blocks.some((e) => e.kind === "enum" && e.name === rawType)
+      )
+        add(
+          "unknown-type",
+          `${b.name}.${name} has unknown field type ${rawType}.`,
+          loc,
+          b.name,
+          name,
+          "Use a supported primitive or declared enum; declare joins in a relationship block.",
+        );
+      const rules = {};
+      const tokens = [];
+      let rest = m[3].trim();
+      while (rest) {
+        const rule =
+          /^(required|min|max|minlength|maxlength|pattern)(?:\(([^\n]*?)\))?(?=\s|$)/.exec(
+            rest,
+          );
+        if (!rule) {
+          add(
+            "invalid-rule",
+            `Unsupported or malformed validation: ${rest}.`,
+            loc,
+            b.name,
+            name,
+            "Use required, min(n), max(n), minlength(n), maxlength(n), or pattern(regex).",
+          );
+          break;
+        }
+        const [token, key, arg] = rule;
+        if (Object.hasOwn(rules, key))
+          add(
+            "duplicate-rule",
+            `Duplicate validation ${key}.`,
+            loc,
+            b.name,
+            name,
+            "Keep a single value for each validation rule.",
+          );
+        rules[key] = arg;
+        const numeric = [
+            "Integer",
+            "Long",
+            "BigDecimal",
+            "Float",
+            "Double",
+          ].includes(type),
+          string = ["String", "TextBlob", "UUID"].includes(type);
+        if (
+          key !== "required" &&
+          (!arg || (["min", "max"].includes(key) ? !numeric : !string))
+        )
+          add(
+            "invalid-rule",
+            `${key} is invalid for ${b.name}.${name} (${rawType}).`,
+            loc,
+            b.name,
+            name,
+            "Use a validation appropriate to the field type with its required argument.",
+          );
+        if (key === "required" && arg !== undefined)
+          add(
+            "invalid-rule",
+            "required does not accept an argument.",
+            loc,
+            b.name,
+            name,
+          );
+        if (
+          ["min", "max", "minlength", "maxlength"].includes(key) &&
+          (!Number.isFinite(Number(arg)) ||
+            arg === undefined ||
+            (["minlength", "maxlength"].includes(key) &&
+              (!Number.isInteger(Number(arg)) || Number(arg) < 0)))
+        )
+          add(
+            "invalid-rule",
+            `Invalid numeric argument for ${key}.`,
+            loc,
+            b.name,
+            name,
+          );
+        if (key === "pattern") {
+          try {
+            require("./pattern").patternParts(arg);
+          } catch {
+            add(
+              "invalid-pattern",
+              "Invalid regular expression.",
+              loc,
+              b.name,
+              name,
+              "Provide a valid JavaScript regular expression.",
+            );
+          }
+          if (/\s/.test(arg || ""))
+            add(
+              "unsupported-pattern",
+              "Patterns containing literal whitespace are not supported by the current form generator.",
+              loc,
+              b.name,
+              name,
+              "Use an escaped whitespace expression such as \\s.",
+            );
+        }
+        tokens.push(token);
+        rest = rest.slice(token.length).trim();
+      }
+      entityFields.push({
+        fieldName: name,
+        fieldType: type,
+        fieldTypeIsEnum: blocks.some(
+          (e) => e.kind === "enum" && e.name === rawType,
+        ),
+        fieldValidateRules: tokens,
+        comment: source
+          .slice(loc + value.length, offset - 1)
+          .trim()
+          .startsWith("//")
+          ? source
+              .slice(loc + value.length, offset - 1)
+              .trim()
+              .slice(2)
+              .trim()
+          : null,
+      });
+      for (const [min, max] of [
+        ["min", "max"],
+        ["minlength", "maxlength"],
+      ])
+        if (
+          rules[min] !== undefined &&
+          rules[max] !== undefined &&
+          Number(rules[min]) > Number(rules[max])
+        )
+          add(
+            "invalid-range",
+            `${min} exceeds ${max}.`,
+            loc,
+            b.name,
+            name,
+            "Make the lower bound less than or equal to the upper bound.",
+          );
+    }
+    const annotationFlags = new Set(b.annotations);
+    const hasAuditAnnotation = annotationFlags.has(
+      isGdl ? "Audited" : "EnableAudit",
+    );
+    const hasActiveStatus = annotationFlags.has("ActiveStatus");
+
+    if (hasActiveStatus && !members.has("isActive")) {
+      members.add("isActive");
+      entityFields.push({ ...ACTIVE_STATUS_FIELD });
+    }
+
+    if (hasAuditAnnotation && config.fields?.audit?.enabled !== false)
+      for (const name of config.fields?.audit?.names ||
+        DEFAULT_AUDIT_FIELDS.map((f) => f.fieldName)) {
+        if (members.has(name))
+          add(
+            "audit-collision",
+            `${b.name}.${name} collides with a generated audit field.`,
+            b.start,
+            b.name,
+            name,
+            "Remove the explicit audit field or disable audit injection.",
+          );
+        members.add(name);
+        entityFields.push({
+          fieldName: name,
+          fieldType:
+            name.toLowerCase().endsWith("date") || /(?:At|_at)$/.test(name)
+              ? "Instant"
+              : "String",
+          fieldTypeIsEnum: false,
+          fieldValidateRules: [],
+          comment: null,
+        });
+      }
+  }
+  const relationships = [];
+  const relationNames = new Set();
+  for (const b of blocks.filter((b) => b.kind === "relationship")) {
+    if (!["OneToOne", "ManyToOne", "OneToMany", "ManyToMany"].includes(b.name))
+      add("relationship-type", `Unknown relationship type ${b.name}.`, b.start);
+    let offset = b.bodyStart;
+    for (const line of b.body.split("\n")) {
+      const value = line.trim(),
+        loc = offset + line.indexOf(value);
+      offset += line.length + 1;
+      if (!value) continue;
+      const m =
+        /^(\w+)(?:[({](\w+)(?:\((\w+)\))?[)}])?\s+to\s+(\w+)(?:[({](\w+)(?:\((\w+)\))?[)}])?$/.exec(
+          value,
+        );
+      if (!m) {
+        add(
+          "relationship-syntax",
+          "Malformed or unsupported relationship declaration.",
+          loc,
+          undefined,
+          undefined,
+          "Use Source{field} to Target{field}, optionally field(displayField).",
+        );
+        continue;
+      }
+      for (const [entity, field, target, display] of [
+        [m[1], m[2], m[4], m[3]],
+        [m[4], m[5], m[1], m[6]],
+      ]) {
+        if (names.get(entity)?.kind !== "entity")
+          add(
+            "missing-entity",
+            `${entity}${field ? "." + field : ""} references an entity that is not defined.`,
+            loc,
+            entity,
+            field,
+            `Define ${entity} or correct the relationship name.`,
+          );
+        if (display && !fields.get(target)?.has(display))
+          add(
+            "missing-display-field",
+            `${entity}.${field} references ${target}.${display}, but that field is not defined.`,
+            loc,
+            entity,
+            field,
+            `Define ${target}.${display} or select an existing display field.`,
+          );
+        if (display && fields.get(target)?.has(display))
+          add(
+            "unsupported-display-field",
+            `Custom relationship display field ${target}.${display} is not implemented by the frontend templates.`,
+            loc,
+            entity,
+            field,
+            "Remove the display-field argument; current selectors use name, title, or id.",
+          );
+        const generated = field || _.camelCase(target);
+        identifier(generated, loc, entity, generated);
+        if (
+          fields.get(entity)?.has(generated) ||
+          fields.get(entity)?.has(generated + "Id")
+        )
+          add(
+            "relationship-collision",
+            `${entity}.${generated} collides with a scalar field or foreign-key field.`,
+            loc,
+            entity,
+            generated,
+            "Remove the duplicate scalar/foreign-key field or rename the relationship.",
+          );
+        const key = entity + "." + generated;
+        if (relationNames.has(key))
+          add(
+            "relationship-collision",
+            `Duplicate generated relationship ${key}.`,
+            loc,
+            entity,
+            generated,
+          );
+        relationNames.add(key);
+      }
+      relationships.push({
+        type: b.name,
+        from: { name: m[1], fieldName: m[2] },
+        to: { name: m[4], fieldName: m[5] },
+      });
+    }
+  }
+  if (!blocks.some((b) => b.kind === "entity"))
+    add(
+      "empty-schema",
+      "No entities are defined.",
+      0,
+      undefined,
+      undefined,
+      "Add at least one entity.",
+    );
+  if (config.generate?.relationships === false && relationships.length)
+    add(
+      "disabled-relationships",
+      "Relationships are declared but relationship generation is disabled.",
+      0,
+      undefined,
+      undefined,
+      "Enable generate.relationships or remove these declarations.",
+      "warning",
+    );
+  require("./backend-diagnostics").checkBackend(config, add);
+  let parsed = null;
+  if (!diagnostics.some((d) => d.severity === "error")) {
+    parsed = {
+      entities: normalizedEntities,
+      enums: blocks
+        .filter((b) => b.kind === "enum")
+        .map((b) => ({
+          name: b.name,
+          values: b.body.split(",").map((v) => ({ name: v.trim() })),
+        })),
+      relationships,
+    };
+    try {
+      require("../config/field-preferences").validateFieldPreferences(
+        config,
+        parsed.entities,
+        config._configPath || file,
+      );
+    } catch (error) {
+      add(
+        "field-configuration",
+        error.message,
+        0,
+        undefined,
+        undefined,
+        "Correct the configured field preferences.",
+      );
+    }
+  }
+  return { diagnostics, parsed };
+}
+function formatDiagnostics(diagnostics) {
+  return diagnostics
+    .map(
+      (d) =>
+        `${d.file}:${d.line || 1}:${d.column || 1} [${d.severity}] ${d.code}${d.entity ? " " + d.entity + (d.field ? "." + d.field : "") : ""}: ${d.message} ${d.suggestion}`,
+    )
+    .join("\n");
+}
+function requireValidSchema(source, options) {
+  const result = analyzeSchema(source, options);
+  if (result.diagnostics.some((d) => d.severity === "error")) {
+    const error = new Error(formatDiagnostics(result.diagnostics));
+    error.diagnostics = result.diagnostics;
+    throw error;
+  }
+  return result;
+}
+module.exports = { analyzeSchema, requireValidSchema, formatDiagnostics };

package/src/validator/pattern.js

@@ -0,0 +1,28 @@
+// Accept the existing quoted strings / RegExp literals and plain pattern bodies.
+function patternParts(argument) {
+  const value = argument.trim();
+  if (value.startsWith("/")) {
+    const end = value.lastIndexOf("/");
+    if (end === 0) throw new Error("Unclosed regular expression literal.");
+    const source = value.slice(1, end),
+      flags = value.slice(end + 1);
+    new RegExp(source, flags);
+    return { source, flags, literal: true };
+  }
+  const source = value.replace(/^['"]|['"]$/g, "");
+  new RegExp(source);
+  return { source, flags: "", literal: false };
+}
+function patternExpression(argument) {
+  const p = patternParts(argument);
+  return p.literal
+    ? `new RegExp(${JSON.stringify(p.source)}, ${JSON.stringify(p.flags)})`
+    : JSON.stringify(p.source);
+}
+function matchesPattern(argument, value) {
+  const p = patternParts(argument);
+  return new RegExp(p.literal ? p.source : `^(?:${p.source})$`, p.flags).test(
+    String(value),
+  );
+}
+module.exports = { patternParts, patternExpression, matchesPattern };