@finebi/finebi-cli 1.2.0

package/src/schema-validator.js

@@ -0,0 +1,194 @@
+import {cliError} from "./errors.js";
+
+export function validateSchemaValue(value, schema, path) {
+  const effectiveSchema = schema || {};
+  // nullable 是 capability 显式声明的字段级约束；required 只控制字段是否必须出现。
+  if (value === null && effectiveSchema.nullable === true) {
+    return { ok: true };
+  }
+  const typeError = validateType(value, effectiveSchema, path);
+  if (typeError) {
+    return typeError;
+  }
+
+  if (effectiveSchema.discriminator && Array.isArray(effectiveSchema.variants)) {
+    return validateDiscriminator(value, effectiveSchema, path);
+  }
+
+  if (effectiveSchema.type === "object") {
+    return validateObject(value, effectiveSchema, path);
+  }
+  if (effectiveSchema.type === "array") {
+    return validateArray(value, effectiveSchema, path);
+  }
+  return validateScalar(value, effectiveSchema, path);
+}
+
+function validateType(value, schema, path) {
+  switch (schema.type) {
+    case "object":
+      if (!isPlainObject(value)) {
+        return invalidRequestJson(path, `Expected object at "${path}".`);
+      }
+      return null;
+    case "array":
+      if (!Array.isArray(value)) {
+        return invalidRequestJson(path, `Expected array at "${path}".`);
+      }
+      return null;
+    case "string":
+      if (typeof value !== "string") {
+        return invalidRequestJson(path, `Expected string at "${path}".`);
+      }
+      return null;
+    case "integer":
+      if (!Number.isInteger(value)) {
+        return invalidRequestJson(path, `Expected integer at "${path}".`);
+      }
+      return null;
+    case "number":
+      if (typeof value !== "number" || !Number.isFinite(value)) {
+        return invalidRequestJson(path, `Expected number at "${path}".`);
+      }
+      return null;
+    case "boolean":
+      if (typeof value !== "boolean") {
+        return invalidRequestJson(path, `Expected boolean at "${path}".`);
+      }
+      return null;
+    default:
+      return null;
+  }
+}
+
+function validateDiscriminator(value, schema, path) {
+  const discriminator = schema.discriminator;
+  const discriminatorPath = joinPath(path, discriminator);
+  if (!Object.prototype.hasOwnProperty.call(value, discriminator)) {
+    return invalidRequestJson(discriminatorPath, `Missing discriminator field "${discriminator}".`);
+  }
+  const discriminatorValue = value[discriminator];
+  const variant = schema.variants.find((item) => item.value === discriminatorValue);
+  if (!variant) {
+    return invalidRequestJson(
+      discriminatorPath,
+      `Unsupported discriminator value "${discriminatorValue}" for "${discriminator}". Expected one of: ${schema.variants.map((item) => item.value).join(", ")}.`,
+    );
+  }
+  const validation = validateSchemaValue(value, variant.schema, path);
+  if (!validation.ok && validation.error.message.startsWith("Unsupported field ")) {
+    return {
+      ok: false,
+      error: {
+        ...validation.error,
+        message: `${validation.error.message.slice(0, -1)} for discriminator "${discriminator}" value "${discriminatorValue}".`,
+      },
+    };
+  }
+  return validation;
+}
+
+function validateObject(value, schema, path) {
+  const properties = schema.properties || {};
+  for (const requiredField of schema.required || []) {
+    if (!Object.prototype.hasOwnProperty.call(value, requiredField)) {
+      return invalidRequestJson(joinPath(path, requiredField), `Missing required field "${requiredField}".`);
+    }
+  }
+  if (Object.keys(properties).length > 0) {
+    for (const fieldName of Object.keys(value)) {
+      if (!Object.prototype.hasOwnProperty.call(properties, fieldName)) {
+        return invalidRequestJson(joinPath(path, fieldName), `Unsupported field "${fieldName}".`);
+      }
+    }
+  }
+  for (const fieldName of Object.keys(properties)) {
+    if (!Object.prototype.hasOwnProperty.call(value, fieldName)) {
+      continue;
+    }
+    const validation = validateSchemaValue(value[fieldName], nestedSchema(properties[fieldName]), joinPath(path, fieldName));
+    if (!validation.ok) {
+      return validation;
+    }
+  }
+  return { ok: true };
+}
+
+function validateArray(value, schema, path) {
+  if (schema.minItems !== undefined && schema.minItems !== null && value.length < Number(schema.minItems)) {
+    return invalidRequestJson(path, `"${path}" must contain at least ${schema.minItems} item(s).`);
+  }
+  const itemSchema = schema.items;
+  if (!itemSchema) {
+    return { ok: true };
+  }
+  for (let index = 0; index < value.length; index += 1) {
+    const validation = validateSchemaValue(value[index], nestedSchema(itemSchema), `${path}[${index}]`);
+    if (!validation.ok) {
+      return validation;
+    }
+  }
+  return { ok: true };
+}
+
+function validateScalar(value, schema, path) {
+  const constValue = schema.constValue ?? schema.const;
+  if (constValue !== undefined && constValue !== null && value !== constValue) {
+    return invalidRequestJson(path, `"${path}" must equal ${JSON.stringify(constValue)}.`);
+  }
+  const enumValues = schema.enumValues || schema.enum || [];
+  if (enumValues.length > 0 && !enumValues.includes(value)) {
+    return invalidRequestJson(path, `"${path}" must be one of: ${enumValues.join(", ")}.`);
+  }
+  if ((schema.type === "integer" || schema.type === "number") && schema.minimum !== undefined && schema.minimum !== null && value < Number(schema.minimum)) {
+    return invalidRequestJson(path, `"${path}" must be greater than or equal to ${schema.minimum}.`);
+  }
+  if ((schema.type === "integer" || schema.type === "number") && schema.maximum !== undefined && schema.maximum !== null && value > Number(schema.maximum)) {
+    return invalidRequestJson(path, `"${path}" must be less than or equal to ${schema.maximum}.`);
+  }
+  if (schema.type === "string" && schema.pattern && !new RegExp(schema.pattern).test(value)) {
+    return invalidRequestJson(path, `"${path}" must match pattern ${schema.pattern}.`);
+  }
+  if (schema.type === "string" && schema.minLength !== undefined && schema.minLength !== null
+      && value.length < Number(schema.minLength)) {
+    return invalidRequestJson(path, `"${path}" must contain at least ${schema.minLength} character(s).`);
+  }
+  if (schema.type === "string" && schema.maxLength !== undefined && schema.maxLength !== null
+      && value.length > Number(schema.maxLength)) {
+    return invalidRequestJson(path, `"${path}" must contain at most ${schema.maxLength} character(s).`);
+  }
+  return { ok: true };
+}
+
+function nestedSchema(property) {
+  if (!property.schema) {
+    return property;
+  }
+  return {
+    ...property.schema,
+    nullable: property.nullable ?? property.schema.nullable,
+    discriminator: property.discriminator ?? property.schema.discriminator,
+    variants: property.variants ?? property.schema.variants,
+  };
+}
+
+function joinPath(base, fieldName) {
+  return base ? `${base}.${fieldName}` : fieldName;
+}
+
+function isPlainObject(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function invalidRequestJson(path, message) {
+  return {
+    ok: false,
+      error: cliError("INVALID_REQUEST_JSON", {
+      path,
+      message,
+      hint: "Remove unsupported fields or check the command schema.",
+      retryable: false,
+      nextActions: ["finebi-cli --help"],
+      }),
+  };
+}