@pplethai/cli 0.6.0 → 0.8.0

package/templates/golden-path/src/dataset-schema.ts

@@ -0,0 +1,398 @@
+// A copy of workers/src/shared/registry/schema.ts.
+//
+// The template is copied into a Builder App, which cannot import the platform
+// package. dataset-query.ts uses canonicalJson, isPlainObject and
+// valueProblems from this copy so a filter value is accepted or refused the
+// same way offline as in the warehouse.
+
+// The JSON Schema subset a Dataset Object Type may declare (ADR-0027).
+// Anything outside this list is refused, so a Provider cannot smuggle a
+// keyword the sweep would not enforce. The root is an object. Nested
+// schemas use the same list. `null` is allowed only inside a type list.
+
+const SCHEMA_KEYS = new Set([
+  "type",
+  "properties",
+  "required",
+  "items",
+  "enum",
+  "format",
+  "minimum",
+  "maximum",
+  "maxLength",
+  "description",
+]);
+
+const TYPE_NAMES = new Set(["string", "number", "integer", "boolean", "object", "array", "null"]);
+const FORMATS = new Set(["date", "date-time", "email", "uri"]);
+const SCALAR_TYPES = new Set(["string", "number", "integer", "boolean"]);
+
+/** How deep a nested schema may go. A sweep page is a document, not a tree. */
+const MAX_DEPTH = 32;
+
+const KEY_LIST =
+  "type, properties, required, items, enum, format, minimum, maximum, maxLength และ description";
+
+export function isPlainObject(value: unknown): value is Record<string, unknown> {
+  return (
+    value !== null &&
+    typeof value === "object" &&
+    !Array.isArray(value) &&
+    Object.getPrototypeOf(value) === Object.prototype
+  );
+}
+
+/** Stable JSON: object keys sorted, array order kept. Used to see whether a schema changed. */
+export function canonicalJson(value: unknown): string {
+  return JSON.stringify(canonicalize(value));
+}
+
+function canonicalize(value: unknown): unknown {
+  if (Array.isArray(value)) return value.map(canonicalize);
+  if (!isPlainObject(value)) return value;
+  const out: Record<string, unknown> = {};
+  for (const key of Object.keys(value).sort()) out[key] = canonicalize(value[key]);
+  return out;
+}
+
+/**
+ * Every problem in one schema, each a Thai sentence. `root` is the Object
+ * Type's schema, which must be an object. An empty list means the schema is
+ * in the subset.
+ */
+export function schemaProblems(schema: unknown, root = true): string[] {
+  return walkSchema(schema, "", root, 0);
+}
+
+function walkSchema(schema: unknown, path: string, root: boolean, depth: number): string[] {
+  const where = path === "" ? "schema" : `schema ที่ ${path}`;
+  if (!isPlainObject(schema)) return [`${where} ต้องเป็นอ็อบเจกต์`];
+  if (depth > MAX_DEPTH) return [`${where} ซ้อนกันเกิน ${MAX_DEPTH} ชั้น`];
+
+  const problems: string[] = [];
+  for (const key of Object.keys(schema).filter((key) => !SCHEMA_KEYS.has(key)).sort()) {
+    problems.push(`${where} ใช้ "${key}" ไม่ได้ — ใช้ได้เฉพาะ ${KEY_LIST}`);
+  }
+
+  const types = readTypes(schema.type);
+  if (!types.ok) {
+    problems.push(
+      `${where}: type ต้องเป็น string, number, integer, boolean, object, array, null หรือรายการของชนิดเหล่านี้`,
+    );
+  } else if (root && (types.names.length !== 1 || types.names[0] !== "object")) {
+    problems.push(`${where} ที่รากต้องมี type เป็น object`);
+  }
+
+  if (!types.ok) return problems;
+  const names = new Set(types.names);
+  const has = (type: string) => names.has(type);
+
+  if ("properties" in schema) {
+    if (!has("object")) {
+      problems.push(`${where}: properties ใช้ได้เมื่อ type เป็น object`);
+    } else if (!isPlainObject(schema.properties)) {
+      problems.push(`${where}: properties ต้องเป็นชื่อฟิลด์และ schema`);
+    } else {
+      for (const key of Object.keys(schema.properties).sort()) {
+        if (key === "") problems.push(`${where}: ชื่อฟิลด์ใน properties ต้องไม่ว่าง`);
+        const child = path === "" ? key : `${path}.${key}`;
+        problems.push(...walkSchema(schema.properties[key], child, false, depth + 1));
+      }
+    }
+  } else if (has("object") && root) {
+    // A root object may declare no fields. Nested objects may too.
+  }
+
+  if ("required" in schema) {
+    if (!has("object")) {
+      problems.push(`${where}: required ใช้ได้เมื่อ type เป็น object`);
+    } else if (
+      !Array.isArray(schema.required) ||
+      schema.required.some((item) => typeof item !== "string" || item === "")
+    ) {
+      problems.push(`${where}: required ต้องเป็นรายชื่อฟิลด์`);
+    } else if (!isPlainObject(schema.properties)) {
+      problems.push(`${where}: required ต้องอ้างฟิลด์ที่ประกาศใน properties`);
+    } else {
+      const seen = new Set<string>();
+      for (const name of schema.required) {
+        if (seen.has(name)) problems.push(`${where}: required ระบุ "${name}" ซ้ำ`);
+        seen.add(name);
+        if (!Object.hasOwn(schema.properties, name)) {
+          problems.push(`${where}: required อ้าง "${name}" ที่ไม่มีใน properties`);
+        }
+      }
+    }
+  }
+
+  if ("items" in schema) {
+    if (!has("array")) {
+      problems.push(`${where}: items ใช้ได้เมื่อ type เป็น array`);
+    } else if (Array.isArray(schema.items)) {
+      problems.push(`${where}: items ต้องเป็น schema เดียว`);
+    } else {
+      const child = path === "" ? "items" : `${path}.items`;
+      problems.push(...walkSchema(schema.items, child, false, depth + 1));
+    }
+  } else if (has("array")) {
+    problems.push(`${where}: type เป็น array ต้องมี items`);
+  }
+
+  if ("enum" in schema) {
+    if (!Array.isArray(schema.enum) || schema.enum.length === 0) {
+      problems.push(`${where}: enum ต้องมีอย่างน้อย 1 ค่า`);
+    } else {
+      schema.enum.forEach((item, index) => {
+        const fit = valueProblems(schema, item);
+        if (fit.length > 0) {
+          problems.push(`${where}: ค่าที่ ${index + 1} ใน enum ไม่ตรงกับ schema`);
+        }
+      });
+    }
+  }
+
+  if ("format" in schema) {
+    if (!has("string")) {
+      problems.push(`${where}: format ใช้ได้เมื่อ type เป็น string`);
+    } else if (typeof schema.format !== "string" || !FORMATS.has(schema.format)) {
+      problems.push(`${where}: format ต้องเป็น date, date-time, email หรือ uri`);
+    }
+  }
+
+  if ("maxLength" in schema) {
+    if (!has("string")) {
+      problems.push(`${where}: maxLength ใช้ได้เมื่อ type เป็น string`);
+    } else if (!nonNegativeInteger(schema.maxLength)) {
+      problems.push(`${where}: maxLength ต้องเป็นจำนวนเต็มที่ไม่ติดลบ`);
+    }
+  }
+
+  const hasNumber = has("number") || has("integer");
+  if ("minimum" in schema || "maximum" in schema) {
+    if (!hasNumber) {
+      problems.push(`${where}: minimum และ maximum ใช้ได้เมื่อ type เป็น number หรือ integer`);
+    } else {
+      if ("minimum" in schema && !finiteNumber(schema.minimum)) {
+        problems.push(`${where}: minimum ต้องเป็นจำนวน`);
+      }
+      if ("maximum" in schema && !finiteNumber(schema.maximum)) {
+        problems.push(`${where}: maximum ต้องเป็นจำนวน`);
+      }
+      if (
+        finiteNumber(schema.minimum) &&
+        finiteNumber(schema.maximum) &&
+        schema.minimum > schema.maximum
+      ) {
+        problems.push(`${where}: minimum ต้องไม่มากกว่า maximum`);
+      }
+    }
+  }
+
+  if ("description" in schema && typeof schema.description !== "string") {
+    problems.push(`${where}: description ต้องเป็นข้อความ`);
+  }
+
+  return problems;
+}
+
+/**
+ * Whether one JSON value fits a schema the subset already accepted. Each
+ * problem is a Thai sentence about the value, not the schema. An empty list
+ * means it fits. Extra properties are kept: the sweep drops them later.
+ */
+export function valueProblems(schema: unknown, value: unknown): string[] {
+  if (!isPlainObject(schema)) return ["ค่าไม่ตรงกับ schema"];
+  const types = readTypes(schema.type);
+  if (!types.ok) return ["ค่าไม่ตรงกับ schema"];
+  return valueWalk(schema, types.names, value);
+}
+
+/**
+ * A copy of `value` with every property the schema does not declare removed,
+ * at every depth. The names are dotted paths (`address.note`), each once.
+ * Array items share their array's path, so the same undeclared field on
+ * every item is one name. The input is not changed.
+ */
+export function dropUndeclared(schema: unknown, value: unknown): { value: unknown; dropped: string[] } {
+  const dropped: string[] = [];
+  const next = dropWalk(schema, value, "", dropped);
+  return { value: next, dropped: [...new Set(dropped)].sort() };
+}
+
+function dropWalk(schema: unknown, value: unknown, path: string, dropped: string[]): unknown {
+  if (!isPlainObject(schema) || value === null) return value;
+  const types = readTypes(schema.type);
+  if (!types.ok) return value;
+  if (types.names.includes("object") && isPlainObject(value)) {
+    const properties = isPlainObject(schema.properties) ? schema.properties : {};
+    const out: Record<string, unknown> = {};
+    for (const key of Object.keys(value)) {
+      const child = path === "" ? key : `${path}.${key}`;
+      // Own keys only: \`in\` would also match Object.prototype names such as
+      // "constructor" or "toString", and keep an undeclared field.
+      if (!Object.hasOwn(properties, key)) {
+        dropped.push(child);
+        continue;
+      }
+      // defineProperty, so a declared "__proto__" stays an own field.
+      Object.defineProperty(out, key, {
+        value: dropWalk(properties[key], value[key], child, dropped),
+        enumerable: true,
+        writable: true,
+        configurable: true,
+      });
+    }
+    return out;
+  }
+  if (types.names.includes("array") && Array.isArray(value) && isPlainObject(schema.items)) {
+    return value.map((item) => dropWalk(schema.items, item, path, dropped));
+  }
+  return value;
+}
+
+function valueWalk(schema: Record<string, unknown>, types: readonly string[], value: unknown): string[] {
+  if (value === null) {
+    if (!types.includes("null")) return ["ต้องไม่เป็น null"];
+    if ("enum" in schema && Array.isArray(schema.enum) && !schema.enum.some((item) => item === null)) {
+      return ["ต้องเป็นหนึ่งในค่าที่กำหนด"];
+    }
+    return [];
+  }
+  const matched = types.filter((type) => type !== "null" && valueIs(type, value));
+  if (matched.length === 0) return [expected(types)];
+
+  const problems: string[] = [];
+  if ("enum" in schema && Array.isArray(schema.enum) && !schema.enum.some((item) => sameValue(item, value))) {
+    problems.push("ต้องเป็นหนึ่งในค่าที่กำหนด");
+  }
+  if (matched.includes("string") && typeof value === "string") {
+    if (typeof schema.format === "string" && !formatFits(schema.format, value)) {
+      problems.push(`ต้องเป็นรูปแบบ ${schema.format}`);
+    }
+    if (typeof schema.maxLength === "number" && [...value].length > schema.maxLength) {
+      problems.push(`ยาวเกิน ${schema.maxLength} ตัวอักษร`);
+    }
+  }
+  if ((matched.includes("number") || matched.includes("integer")) && typeof value === "number") {
+    if (typeof schema.minimum === "number" && value < schema.minimum) {
+      problems.push(`ต้องไม่น้อยกว่า ${schema.minimum}`);
+    }
+    if (typeof schema.maximum === "number" && value > schema.maximum) {
+      problems.push(`ต้องไม่เกิน ${schema.maximum}`);
+    }
+  }
+  if (matched.includes("object") && isPlainObject(value)) {
+    const properties = isPlainObject(schema.properties) ? schema.properties : {};
+    const required = Array.isArray(schema.required)
+      ? schema.required.filter((item): item is string => typeof item === "string")
+      : [];
+    for (const key of required) {
+      if (!Object.hasOwn(value, key)) problems.push(`ต้องมี "${key}"`);
+    }
+    for (const key of Object.keys(properties).sort()) {
+      if (!Object.hasOwn(value, key)) continue;
+      const child = properties[key];
+      if (!isPlainObject(child)) continue;
+      const nested = valueProblems(child, value[key]);
+      for (const problem of nested) problems.push(`${key}: ${problem}`);
+    }
+  }
+  if (matched.includes("array") && Array.isArray(value) && isPlainObject(schema.items)) {
+    value.forEach((item, index) => {
+      for (const problem of valueProblems(schema.items, item)) {
+        problems.push(`รายการที่ ${index + 1}: ${problem}`);
+      }
+    });
+  }
+  return problems;
+}
+
+function expected(types: readonly string[]): string {
+  const names = types.filter((type) => type !== "null");
+  if (names.length === 1) {
+    if (names[0] === "string") return "ต้องเป็นข้อความ";
+    if (names[0] === "integer") return "ต้องเป็นจำนวนเต็ม";
+    if (names[0] === "number") return "ต้องเป็นจำนวน";
+    if (names[0] === "boolean") return "ต้องเป็นจริงหรือเท็จ";
+    if (names[0] === "object") return "ต้องเป็นอ็อบเจกต์";
+    if (names[0] === "array") return "ต้องเป็นรายการ";
+  }
+  return "ต้องตรงกับ type ที่ประกาศ";
+}
+
+function valueIs(type: string, value: unknown): boolean {
+  if (type === "string") return typeof value === "string";
+  if (type === "boolean") return typeof value === "boolean";
+  if (type === "integer") return typeof value === "number" && Number.isInteger(value);
+  if (type === "number") return typeof value === "number" && Number.isFinite(value);
+  if (type === "object") return isPlainObject(value);
+  if (type === "array") return Array.isArray(value);
+  return false;
+}
+
+function formatFits(format: string, value: string): boolean {
+  if (format === "date") return isDate(value);
+  if (format === "date-time") return isDateTime(value);
+  if (format === "email") return /^[^\s@]+@[^\s@]+\.[^\s@]+$/.test(value);
+  if (format === "uri") {
+    try {
+      return new URL(value).protocol.length > 1;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+function isDate(value: string): boolean {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return false;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const date = new Date(Date.UTC(year, month - 1, day));
+  return date.getUTCFullYear() === year && date.getUTCMonth() === month - 1 && date.getUTCDate() === day;
+}
+
+function isDateTime(value: string): boolean {
+  const match = /^(\d{4}-\d{2}-\d{2})T(\d{2}):(\d{2}):(\d{2})(\.\d+)?(Z|[+-]\d{2}:\d{2})$/.exec(value);
+  if (!match) return false;
+  const hour = Number(match[2]);
+  const minute = Number(match[3]);
+  const second = Number(match[4]);
+  if (hour > 23 || minute > 59 || second > 60) return false;
+  return isDate(match[1] ?? "");
+}
+
+function sameValue(left: unknown, right: unknown): boolean {
+  return canonicalJson(left) === canonicalJson(right);
+}
+
+function readTypes(value: unknown): { ok: true; names: string[] } | { ok: false } {
+  const list = typeof value === "string" ? [value] : Array.isArray(value) ? value : null;
+  if (!list || list.length === 0) return { ok: false };
+  if (!list.every((item) => typeof item === "string" && TYPE_NAMES.has(item))) return { ok: false };
+  if (new Set(list).size !== list.length) return { ok: false };
+  return { ok: true, names: list };
+}
+
+function finiteNumber(value: unknown): value is number {
+  return typeof value === "number" && Number.isFinite(value);
+}
+
+function nonNegativeInteger(value: unknown): boolean {
+  return typeof value === "number" && Number.isInteger(value) && value >= 0;
+}
+
+/** A top-level property an `index` may name: a scalar, or a scalar that may be null. */
+export function isScalarSchema(schema: unknown): boolean {
+  if (!isPlainObject(schema)) return false;
+  const types = readTypes(schema.type);
+  if (!types.ok) return false;
+  return types.names.every((type) => type === "null" || SCALAR_TYPES.has(type));
+}
+
+/** The id property: exactly string or integer, never null and never a list. */
+export function isIdSchema(schema: unknown): boolean {
+  return isPlainObject(schema) && (schema.type === "string" || schema.type === "integer");
+}