@wix/himalaya-cli 0.1430.0 → 0.1432.0

package/dist/authoring-runtime/node_modules/@wix/himalaya/dist/data-resources.mjs

@@ -1,3 +1,176 @@
+// ../../core/data-resources/src/base44/schema.ts
+var BASE44_FIELD_TYPES = ["string", "number", "integer", "boolean", "array", "object"];
+var BASE44_STRING_FORMATS = ["date", "date-time", "time", "email", "uri", "uuid", "file", "richtext"];
+var BASE44_BUILTIN_FIELDS = ["id", "created_date", "updated_date", "created_by", "created_by_id"];
+
+// ../../core/data-resources/src/base44/ownership.ts
+function base44Prefix(app) {
+  const runs = app.match(/[A-Za-z0-9]+/g) ?? [];
+  return `Himi${runs.map((r) => r.charAt(0).toUpperCase() + r.slice(1)).join("")}`;
+}
+function nonEmpty(value) {
+  return typeof value === "string" && value.trim() !== "";
+}
+function isAdoptedEntity(spec) {
+  return nonEmpty(spec.base44Name);
+}
+function isOwnedEntity(spec) {
+  return !isAdoptedEntity(spec) && nonEmpty(spec.name);
+}
+function physicalEntityName(spec, app) {
+  if (isAdoptedEntity(spec)) return spec.base44Name;
+  return nonEmpty(spec.name) ? `${base44Prefix(app)}${spec.name}` : "";
+}
+function isOwnedFunction(spec) {
+  return !nonEmpty(spec.base44Name) && nonEmpty(spec.name);
+}
+function physicalFunctionName(spec) {
+  return nonEmpty(spec.base44Name) ? spec.base44Name : nonEmpty(spec.name) ? spec.name : "";
+}
+var ENTITY_NAME = /^[A-Za-z][A-Za-z0-9]*$/;
+var FUNCTION_NAME = /^[A-Za-z0-9][A-Za-z0-9_-]*$/;
+function label(spec) {
+  if (nonEmpty(spec.base44Name)) return spec.base44Name;
+  if (nonEmpty(spec.name)) return spec.name;
+  return "<unnamed>";
+}
+function userScoped(rule) {
+  if (rule === void 0) return false;
+  try {
+    return (JSON.stringify(rule) ?? "").includes("{{user.");
+  } catch {
+    return false;
+  }
+}
+function validateBase44Entities(cfg, app) {
+  if (!cfg) return [];
+  const issues = [];
+  const add = (severity, ruleCode, entity, message) => issues.push({ severity, ruleCode, message, ...entity !== void 0 ? { entity } : {} });
+  const err = (ruleCode, entity, message) => add("error", ruleCode, entity, message);
+  const prefix = base44Prefix(app);
+  const types = new Set(BASE44_FIELD_TYPES);
+  const formats = new Set(BASE44_STRING_FORMATS);
+  const builtins = new Set(BASE44_BUILTIN_FIELDS);
+  if (cfg.entities !== void 0 && !Array.isArray(cfg.entities)) err("shape-invalid", void 0, "base44.entities must be an array");
+  const seen = /* @__PURE__ */ new Set();
+  for (const raw of Array.isArray(cfg.entities) ? cfg.entities : []) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      err("shape-invalid", void 0, "every base44 entity declaration must be an object");
+      continue;
+    }
+    const spec = raw;
+    const name = label(spec);
+    const rawName = spec.name;
+    const rawAdopted = spec.base44Name;
+    const hasName = rawName !== void 0;
+    const hasAdopted = rawAdopted !== void 0;
+    if (hasName && hasAdopted) {
+      err("entity-owned-and-adopted", name, "declare either `name` (owned) or `base44Name` (adopted), not both");
+    } else if (!hasName && !hasAdopted) {
+      err("entity-neither-owned-nor-adopted", name, "needs `name` (owned, namespaced) or `base44Name` (adopted, an entity the Base44 app already has)");
+    } else {
+      const value = hasName ? rawName : rawAdopted;
+      if (typeof value !== "string" || !ENTITY_NAME.test(value)) {
+        err("entity-name-invalid", name, `entity ${hasName ? "name" : "base44Name"} ${JSON.stringify(value)} must be alphanumeric and start with a letter \u2014 Base44 entity names allow nothing else`);
+      } else if (hasAdopted && value.startsWith(prefix)) {
+        err("adopted-in-owned-namespace", name, `adopted entity "${value}" starts with this app's owned prefix "${prefix}" \u2014 himi would treat a foreign entity as its own. Declare it with \`name\` if himi owns it, or rename it.`);
+      }
+    }
+    const physical = physicalEntityName(spec, app);
+    if (physical) {
+      if (seen.has(physical)) err("entity-duplicate", name, `duplicate entity "${physical}"`);
+      seen.add(physical);
+    }
+    const keys = /* @__PURE__ */ new Set();
+    if (!Array.isArray(spec.fields)) {
+      err("shape-invalid", name, "`fields` must be an array");
+    } else {
+      for (const rawField of spec.fields) {
+        if (!rawField || typeof rawField !== "object" || Array.isArray(rawField)) {
+          err("shape-invalid", name, "every field declaration must be an object");
+          continue;
+        }
+        const field = rawField;
+        if (typeof field.key !== "string" || !field.key) {
+          err("shape-invalid", name, "every field needs a string `key`");
+          continue;
+        }
+        if (builtins.has(field.key)) {
+          err("field-builtin", name, `field "${field.key}" is built in \u2014 Base44 adds ${BASE44_BUILTIN_FIELDS.join(", ")} to every row. Remove it from the declaration.`);
+          continue;
+        }
+        if (keys.has(field.key)) err("field-duplicate", name, `duplicate field key "${field.key}"`);
+        keys.add(field.key);
+        if (!types.has(field.type)) err("field-type-unsupported", name, `field "${field.key}" has unsupported type ${JSON.stringify(field.type)} \u2014 supported: ${BASE44_FIELD_TYPES.join(", ")}`);
+        if (field.format !== void 0) {
+          if (field.type !== "string") err("field-format-invalid", name, `field "${field.key}" declares a format but only string fields take one`);
+          else if (!formats.has(field.format)) err("field-format-invalid", name, `field "${field.key}" has unsupported format ${JSON.stringify(field.format)} \u2014 supported: ${BASE44_STRING_FORMATS.join(", ")}`);
+        }
+        if (field.items !== void 0 && (field.type !== "array" || !types.has(field.items?.type))) {
+          err("field-type-unsupported", name, field.type !== "array" ? `field "${field.key}" declares \`items\` but only array fields take one` : `field "${field.key}" has unsupported items type ${JSON.stringify(field.items?.type)} \u2014 supported: ${BASE44_FIELD_TYPES.join(", ")}`);
+        }
+      }
+    }
+    if (spec.displayField !== void 0 && !keys.has(spec.displayField) && !builtins.has(spec.displayField)) {
+      err("display-field-unknown", name, `displayField "${spec.displayField}" is not one of the declared fields (${[...keys].join(", ") || "none"})`);
+    }
+    if (spec.required !== void 0) {
+      if (!Array.isArray(spec.required)) err("shape-invalid", name, "`required` must be an array of field keys");
+      else for (const key of spec.required) {
+        if (!keys.has(key)) err("required-unknown", name, `required field "${key}" is not declared`);
+      }
+    }
+    if (spec.seed !== void 0) {
+      if (hasAdopted) {
+        err("seed-on-adopted", name, "an adopted entity cannot declare `seed` \u2014 himi never writes to entities it does not own");
+      } else if (!Array.isArray(spec.seed)) {
+        err("shape-invalid", name, "seed must be an array of row objects");
+      } else {
+        spec.seed.forEach((row, index) => {
+          if (!row || typeof row !== "object" || Array.isArray(row)) {
+            err("shape-invalid", name, `seed row ${index} must be an object`);
+            return;
+          }
+          for (const key of Object.keys(row)) {
+            if (!keys.has(key)) err("seed-key-unknown", name, `seed row ${index} sets undeclared field "${key}"`);
+          }
+        });
+      }
+    }
+    if (userScoped(spec.rls?.read)) {
+      add("warning", "read-rule-user-scoped", name, "rls.read is scoped to the signed-in user ({{user.\u2026}}), so a signed-out viewer sees an empty list. Gate the screen behind a sign-in, or widen the read rule if the rows are public.");
+    }
+  }
+  if (cfg.functions !== void 0 && !Array.isArray(cfg.functions)) err("shape-invalid", void 0, "base44.functions must be an array");
+  const seenFns = /* @__PURE__ */ new Set();
+  for (const raw of Array.isArray(cfg.functions) ? cfg.functions : []) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+      err("shape-invalid", void 0, "every base44 function declaration must be an object");
+      continue;
+    }
+    const spec = raw;
+    const name = label(spec);
+    const hasName = spec.name !== void 0;
+    const hasAdopted = spec.base44Name !== void 0;
+    if (hasName && hasAdopted) {
+      err("function-owned-and-adopted", name, "declare either `name` (owned) or `base44Name` (adopted), not both");
+      continue;
+    }
+    if (!hasName && !hasAdopted) {
+      err("function-neither-owned-nor-adopted", name, "needs `name` (owned, source under base44/functions/<name>/) or `base44Name` (adopted, an existing backend function)");
+      continue;
+    }
+    const value = hasName ? spec.name : spec.base44Name;
+    if (typeof value !== "string" || !FUNCTION_NAME.test(value)) {
+      err("function-name-invalid", name, `function name ${JSON.stringify(value)} must be letters, digits, "-" or "_"`);
+      continue;
+    }
+    if (seenFns.has(value)) err("function-duplicate", name, `duplicate function "${value}"`);
+    seenFns.add(value);
+  }
+  return issues;
+}
+
 // ../../core/data-resources/src/schema.ts
 var WIX_FIELD_TYPES = [
   "TEXT",
@@ -41,12 +214,22 @@ var KV_DEFAULT_MAX_VALUE_BYTES = 64 * 1024;
 var KV_MAX_VALUE_BYTES = 256 * 1024;
 var KV_MAX_TTL_SECONDS = 365 * 24 * 60 * 60;
 export {
+  BASE44_BUILTIN_FIELDS,
+  BASE44_FIELD_TYPES,
+  BASE44_STRING_FORMATS,
   KV_DEFAULT_MAX_ENTRIES,
   KV_DEFAULT_MAX_VALUE_BYTES,
   KV_MAX_TTL_SECONDS,
   KV_MAX_VALUE_BYTES,
   WIX_FIELD_TYPES,
+  base44Prefix,
+  isAdoptedEntity,
+  isOwnedEntity,
+  isOwnedFunction,
   mergeDataResources,
-  provisionedKvSpec
+  physicalEntityName,
+  physicalFunctionName,
+  provisionedKvSpec,
+  validateBase44Entities
 };
 //# sourceMappingURL=data-resources.mjs.map