@stonecrop/schema 0.13.14 → 0.14.0

package/dist/index-D8R5ppAg.js

@@ -0,0 +1,529 @@
+import { z as e } from "zod";
+import { isScalarType as E, isEnumType as N, isObjectType as T, isNonNullType as L, isListType as v, isNamedType as P, buildSchema as U, buildClientSchema as q } from "graphql";
+const R = e.object({
+  /** The table view type */
+  view: e.enum(["list", "uncounted", "list-expansion", "tree", "gantt", "tree-gantt"]).optional(),
+  /** Allow the table to use the full width of its container */
+  fullWidth: e.boolean().optional(),
+  /** Default expansion state for tree views */
+  defaultTreeExpansion: e.enum(["root", "branch", "leaf"]).optional(),
+  /** Enable dependency graph connections for Gantt views */
+  dependencyGraph: e.boolean().optional()
+}).meta({
+  title: "TableViewConfig",
+  description: "JSON-safe view configuration for table fields in doctype authoring"
+}), V = [
+  "Data",
+  // Short text, varchar
+  "Text",
+  // Long text
+  "Int",
+  // Integer
+  "Float",
+  // Floating point (IEEE 754)
+  "Decimal",
+  // Arbitrary precision decimal
+  "Check",
+  // Boolean/checkbox
+  "Date",
+  // Date only
+  "Time",
+  // Time only
+  "Datetime",
+  // Date and time
+  "Duration",
+  // Time interval
+  "DateRange",
+  // Date range
+  "JSON",
+  // JSON data
+  "Code",
+  // Code/source (with syntax highlighting)
+  "Link",
+  // Reference to another doctype
+  "Attach",
+  // File attachment
+  "Currency",
+  // Currency value
+  "Quantity",
+  // Quantity with unit
+  "Select",
+  // Dropdown selection
+  "PrimaryKey",
+  // Primary key field — used by the middleware to identify the record's PK column
+  "Fieldset",
+  // UI grouping container — no DB column; children are flat columns
+  "Display"
+  // Computed/read-only field — no DB column; excluded from SQL SELECT
+], J = e.string().min(1).meta({
+  title: "StonecropFieldType",
+  description: "Semantic field types for Stonecrop doctypes, consistent across forms and tables"
+});
+function Q(t) {
+  return V.includes(t);
+}
+const W = {
+  // Text
+  Data: { component: "ATextInput", fieldtype: "Data" },
+  Text: { component: "ATextInput", fieldtype: "Text" },
+  // Numeric
+  Int: { component: "ANumericInput", fieldtype: "Int" },
+  Float: { component: "ANumericInput", fieldtype: "Float" },
+  Decimal: { component: "ADecimalInput", fieldtype: "Decimal" },
+  // Boolean
+  Check: { component: "ACheckbox", fieldtype: "Check" },
+  // Date/Time
+  Date: { component: "ADate", fieldtype: "Date" },
+  Time: { component: "ATimeInput", fieldtype: "Time" },
+  Datetime: { component: "ADatetimePicker", fieldtype: "Datetime" },
+  Duration: { component: "ADurationInput", fieldtype: "Duration" },
+  DateRange: { component: "ADateRangePicker", fieldtype: "DateRange" },
+  // Structured
+  JSON: { component: "ACodeEditor", fieldtype: "JSON" },
+  Code: { component: "ACodeEditor", fieldtype: "Code" },
+  // Relational
+  Link: { component: "ALink", fieldtype: "Link" },
+  // Files
+  Attach: { component: "AFileAttach", fieldtype: "Attach" },
+  // Specialized
+  Currency: { component: "ACurrencyInput", fieldtype: "Currency" },
+  Quantity: { component: "AQuantityInput", fieldtype: "Quantity" },
+  Select: { component: "ADropdown", fieldtype: "Select" },
+  // Identity — PK fields are typically hidden; no interactive component is needed
+  PrimaryKey: { component: "ATextInput", fieldtype: "PrimaryKey" },
+  // Layout — UI grouping containers and computed fields with no backing DB column
+  Fieldset: { component: "AFieldset", fieldtype: "Fieldset" },
+  Display: { component: "ATextInput", fieldtype: "Display" }
+};
+function z(t) {
+  return W[t]?.component ?? "ATextInput";
+}
+function ke(t) {
+  return Q(t) ? z(t) : "ATextInput";
+}
+const B = e.union([
+  e.string(),
+  // Link/Doctype target: "customer"
+  e.array(e.string()),
+  // Select choices: ["A", "B", "C"]
+  e.record(e.string(), e.unknown())
+  // Config: \{ precision: 10, scale: 2 \}
+]).meta({
+  title: "FieldOptions",
+  description: "Field options - flexible bag for type-specific configuration"
+}), $ = e.looseObject({
+  /** Error message to display when validation fails */
+  errorMessage: e.string()
+}).meta({
+  title: "FieldValidation",
+  description: "Validation configuration for form fields"
+});
+function G(t) {
+  if (typeof t != "object" || t === null || Array.isArray(t)) return t;
+  const n = t;
+  return "kind" in n ? t : "schema" in n ? { kind: "fieldset", ...n } : "columns" in n ? { kind: "table", ...n } : { kind: "field", ...n };
+}
+function K() {
+  const t = e.object({
+    kind: e.literal("field"),
+    fieldname: e.string().min(1),
+    fieldtype: J,
+    component: e.string().optional(),
+    label: e.string().optional(),
+    width: e.string().optional(),
+    align: e.enum(["left", "center", "right", "start", "end"]).optional(),
+    edit: e.boolean().optional(),
+    mask: e.string().optional(),
+    format: e.string().optional(),
+    mode: e.enum(["edit", "read", "display"]).optional(),
+    options: B.optional(),
+    required: e.boolean().optional(),
+    readOnly: e.boolean().optional(),
+    hidden: e.boolean().optional(),
+    default: e.unknown().optional(),
+    validation: $.optional(),
+    cardinality: e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).optional(),
+    source: e.literal("introspected").optional()
+  }).meta({ title: "ValueField" }), n = e.object({
+    kind: e.literal("table"),
+    fieldname: e.string().min(1),
+    component: e.string().optional(),
+    label: e.string().optional(),
+    // Validates that each column has fieldname; allows all other ColumnSchema properties
+    columns: e.array(e.object({ fieldname: e.string().min(1) }).passthrough()),
+    config: R.optional(),
+    mode: e.enum(["edit", "read", "display"]).optional()
+  }).meta({ title: "TableField" });
+  let o = e.never();
+  const a = e.object({
+    kind: e.literal("fieldset"),
+    fieldname: e.string().min(1),
+    component: e.string().optional(),
+    label: e.string().optional(),
+    collapsible: e.boolean().optional(),
+    mode: e.enum(["edit", "read", "display"]).optional(),
+    schema: e.lazy(() => o.array())
+  }).meta({ title: "FieldsetField" }), r = e.discriminatedUnion("kind", [t, a, n]);
+  return o = e.preprocess(G, r), { ValueFieldSchema: t, TableFieldSchema: n, FieldsetFieldSchema: a, DoctypeFieldSchema: o };
+}
+const S = K(), Ie = S.ValueFieldSchema, Ce = S.FieldsetFieldSchema, Le = S.TableFieldSchema, k = S.DoctypeFieldSchema, Y = e.enum(["atMostOne", "one", "noneOrMany", "atLeastOne"]).meta({
+  title: "Cardinality",
+  description: "Cardinality for relationship links between doctypes"
+}), Z = e.object({
+  /** Fetch method type */
+  method: e.literal("sync"),
+  /** Optional limit on number of records to fetch */
+  limit: e.number().int().positive().optional()
+}).meta({
+  title: "SyncFetch",
+  description: "Sync fetch strategy - data is fetched in the initial query"
+}), H = e.object({
+  /** Fetch method type */
+  method: e.literal("lazy")
+}).meta({
+  title: "LazyFetch",
+  description: "Lazy fetch strategy - data is fetched on demand in a separate query"
+}), X = e.object({
+  /** Fetch method type */
+  method: e.literal("custom"),
+  /** Serialized handler function to invoke */
+  handler: e.string()
+}).meta({
+  title: "CustomFetch",
+  description: "Custom fetch strategy - uses a custom handler function"
+}), ee = e.discriminatedUnion("method", [Z, H, X]).meta({
+  title: "FetchStrategy",
+  description: "Fetch strategy for link data loading"
+}), te = e.object({
+  /** Target doctype slug */
+  target: e.string().min(1),
+  /** Cardinality of the relationship */
+  cardinality: Y,
+  /** Backlink fieldname on the target doctype that points back to this link */
+  backlink: e.string().optional(),
+  /** Override default rendering component (AForm for 1:1, ATable for 1:many) */
+  component: e.string().optional(),
+  /** Fieldname of the corresponding Link field in the fields array */
+  fieldname: e.string().min(1).optional(),
+  /** Fetch strategy for loading nested data */
+  fetch: ee.optional(),
+  /** Whether to block workflow actions until nested data is loaded (default: true) */
+  blockWorkflows: e.boolean().optional()
+}).meta({
+  title: "LinkDeclaration",
+  description: "Declares a relationship from one doctype to another"
+}), ne = e.object({
+  /** Display label for the action */
+  label: e.string().min(1),
+  /** Fields that must have values before action can execute */
+  requiredFields: e.array(e.string()).optional(),
+  /** Workflow states where this action is available */
+  allowedStates: e.array(e.string()).optional(),
+  /** The state the record transitions to after this action executes */
+  nextState: e.string().optional(),
+  /** True for side-effect actions that do not change workflow state (save, print, email, etc.) */
+  stateless: e.boolean().optional(),
+  /** JS function body stored as a string; executed client-side via AsyncFunction with injected API surface */
+  clientHandler: e.string().optional()
+}).meta({
+  title: "ActionDefinition",
+  description: "Action definition within a workflow"
+}), ie = e.object({
+  /** Optional display label; the map key is the trigger's identity */
+  label: e.string().optional(),
+  /** Fieldnames whose edits fire this trigger (fires when any listed field changes) */
+  on: e.array(e.string()),
+  /** JS function body stored as a string; run client-side with `{ record, value, setError }`. Advisory. */
+  clientHandler: e.string()
+}).meta({
+  title: "TriggerDefinition",
+  description: "Reactive field-validation trigger — advisory client-side"
+});
+function _e(t, n) {
+  const o = t.allowedStates;
+  return !o || o.length === 0 ? !0 : o.includes(n);
+}
+const oe = e.object({
+  /** List of workflow states */
+  states: e.array(e.string()).optional(),
+  /** Actions available in this workflow */
+  actions: e.record(e.string(), ne).optional(),
+  /** Reactive field-validation triggers (advisory, client-side), keyed by trigger name */
+  triggers: e.record(e.string(), ie).optional()
+}).meta({
+  title: "WorkflowMeta",
+  description: "Workflow metadata - states and actions for a doctype"
+}), _ = e.object({
+  /** Display name of the doctype */
+  name: e.string().min(1),
+  /** URL-friendly slug (kebab-case) */
+  slug: e.string().min(1).optional(),
+  /** Field definitions (including link fields with fieldtype: 'Link') */
+  fields: e.array(k),
+  /** Relationship links to other doctypes */
+  links: e.record(e.string(), te).optional(),
+  /** Workflow configuration */
+  workflow: oe.optional(),
+  /** Parent doctype for inheritance */
+  inherits: e.string().optional()
+}).meta({
+  title: "DoctypeMeta",
+  description: "Doctype metadata - complete definition of a doctype"
+});
+function we(t) {
+  const n = k.safeParse(t);
+  return n.success ? { success: !0, errors: [] } : {
+    success: !1,
+    errors: n.error.issues.map((o) => ({
+      path: o.path,
+      message: o.message
+    }))
+  };
+}
+function Oe(t) {
+  const n = _.safeParse(t);
+  return n.success ? { success: !0, errors: [] } : {
+    success: !1,
+    errors: n.error.issues.map((o) => ({
+      path: o.path,
+      message: o.message
+    }))
+  };
+}
+function je(t) {
+  return k.parse(t);
+}
+function xe(t) {
+  return _.parse(t);
+}
+function Me(t) {
+  return t.replace(/_([a-z])/g, (n, o) => o.toUpperCase());
+}
+function Ee(t) {
+  return t.replace(/[A-Z]/g, (n) => `_${n.toLowerCase()}`);
+}
+function Ne(t) {
+  return t.split("_").map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join(" ");
+}
+function ae(t) {
+  const n = t.replace(/([A-Z])/g, " $1").trim();
+  return n.charAt(0).toUpperCase() + n.slice(1);
+}
+function re(t) {
+  return t.split(/[-_\s]+/).map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join("");
+}
+function h(t) {
+  return t.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function ve(t) {
+  return t.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+const se = {
+  String: { component: "ATextInput", fieldtype: "Data" },
+  Int: { component: "ANumericInput", fieldtype: "Int" },
+  Float: { component: "ANumericInput", fieldtype: "Float" },
+  Boolean: { component: "ACheckbox", fieldtype: "Check" },
+  ID: { component: "ATextInput", fieldtype: "Data" }
+}, le = {
+  // Arbitrary precision / large numbers
+  BigFloat: { component: "ADecimalInput", fieldtype: "Decimal" },
+  BigDecimal: { component: "ADecimalInput", fieldtype: "Decimal" },
+  Decimal: { component: "ADecimalInput", fieldtype: "Decimal" },
+  BigInt: { component: "ANumericInput", fieldtype: "Int" },
+  Long: { component: "ANumericInput", fieldtype: "Int" },
+  // Identifiers
+  UUID: { component: "ATextInput", fieldtype: "Data" },
+  // Date / Time
+  DateTime: { component: "ADatetimePicker", fieldtype: "Datetime" },
+  Datetime: { component: "ADatetimePicker", fieldtype: "Datetime" },
+  Date: { component: "ADate", fieldtype: "Date" },
+  Time: { component: "ATimeInput", fieldtype: "Time" },
+  Interval: { component: "ADurationInput", fieldtype: "Duration" },
+  Duration: { component: "ADurationInput", fieldtype: "Duration" },
+  // Structured data
+  JSON: { component: "ACodeEditor", fieldtype: "JSON" },
+  JSONObject: { component: "ACodeEditor", fieldtype: "JSON" },
+  JsonNode: { component: "ACodeEditor", fieldtype: "JSON" }
+}, ce = /* @__PURE__ */ new Set(["Cursor"]);
+function pe(t) {
+  const n = { ...le };
+  for (const [o, a] of Object.entries(se))
+    n[o] = a;
+  if (t)
+    for (const [o, a] of Object.entries(t))
+      n[o] = {
+        component: a.component ?? "ATextInput",
+        fieldtype: a.fieldtype ?? "Data"
+      };
+  return n;
+}
+const de = [
+  "Connection",
+  "Edge",
+  "Input",
+  "Patch",
+  "Payload",
+  "Condition",
+  "Filter",
+  "OrderBy",
+  "Aggregate",
+  "AggregateResult",
+  "AggregateFilter",
+  "DeleteResponse",
+  "InsertResponse",
+  "UpdateResponse",
+  "MutationResponse"
+], ue = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]);
+function me(t, n) {
+  if (t.startsWith("__") || ue.has(t) || t === "Node")
+    return !1;
+  for (const a of de)
+    if (t.endsWith(a))
+      return !1;
+  const o = n.getFields();
+  return Object.keys(o).length !== 0;
+}
+const fe = /* @__PURE__ */ new Set(["nodeId", "__typename", "clientMutationId"]);
+function ye(t, n, o) {
+  return !fe.has(t);
+}
+function b(t) {
+  let n = !1, o = !1, a = t;
+  if (L(a) && (n = !0, a = a.ofType), v(a) && (o = !0, a = a.ofType, L(a) && (a = a.ofType)), !P(a))
+    throw new Error(`Expected a named GraphQL type, got: ${String(a)}`);
+  return { namedType: a, required: n, isList: o };
+}
+function ge(t) {
+  const o = t.getFields().edges;
+  if (!o) return;
+  const { namedType: a, isList: r } = b(o.type);
+  if (!r || !T(a)) return;
+  const d = a.getFields().node;
+  if (!d) return;
+  const { namedType: u } = b(d.type);
+  if (T(u))
+    return u.name;
+}
+function he(t, n, o, a = {}) {
+  const { namedType: r, required: y, isList: d } = b(n.type), u = pe(a.customScalars), i = {
+    kind: "field",
+    fieldname: t,
+    label: ae(t),
+    component: "ATextInput",
+    fieldtype: "Data"
+  };
+  if (y && (i.required = !0), E(r)) {
+    if (ce.has(r.name))
+      return i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i;
+    if (r.name === "ID") {
+      const m = re(t);
+      if (o.has(m))
+        return i.component = "ALink", i.fieldtype = "Link", i.options = h(m), i;
+    }
+    const l = u[r.name];
+    return l ? (i.component = l.component, i.fieldtype = l.fieldtype) : (i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name)), i;
+  }
+  if (N(r))
+    return i.component = "ADropdown", i.fieldtype = "Select", i.options = r.getValues().map((l) => l.name), i;
+  if (T(r)) {
+    if (!d && o.has(r.name))
+      return i.component = "ALink", i.fieldtype = "Link", i.options = h(r.name), i;
+    const l = ge(r);
+    return l && o.has(l) ? (i.component = "ATable", i._isLink = !0, i.options = h(l), i.cardinality = "noneOrMany", delete i.fieldtype, i) : d && o.has(r.name) ? (i.component = "ATable", i._isLink = !0, i.options = h(r.name), i.cardinality = "noneOrMany", delete i.fieldtype, i) : (i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i);
+  }
+  return i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i;
+}
+function Pe(t, n = {}) {
+  const o = Te(t), a = o.getTypeMap(), r = /* @__PURE__ */ new Set(), y = o.getQueryType(), d = o.getMutationType(), u = o.getSubscriptionType();
+  y && r.add(y.name), d && r.add(d.name), u && r.add(u.name);
+  const i = n.isEntityType ?? me, l = /* @__PURE__ */ new Set();
+  for (const [c, p] of Object.entries(a))
+    T(p) && (r.has(c) || i(c, p) && l.add(c));
+  let m = l;
+  if (n.include) {
+    const c = new Set(n.include);
+    m = new Set([...l].filter((p) => c.has(p)));
+  }
+  if (n.exclude) {
+    const c = new Set(n.exclude);
+    m = new Set([...m].filter((p) => !c.has(p)));
+  }
+  const w = n.isEntityField ?? ye, I = [];
+  for (const c of m) {
+    const p = a[c];
+    if (!T(p)) continue;
+    const O = p.getFields(), C = n.typeOverrides?.[c], j = Object.entries(O).filter(([s, g]) => w(s, g, p)).map(([s, g]) => {
+      if (n.classifyField) {
+        const f = n.classifyField(s, g, p);
+        if (f != null)
+          return {
+            kind: "field",
+            fieldname: s,
+            label: f.label ?? s,
+            component: f.component ?? "ATextInput",
+            fieldtype: f.fieldtype ?? "Data",
+            ...f
+          };
+      }
+      const A = he(s, g, l, n);
+      return C?.[s] ? Object.assign(A, C[s]) : A;
+    }), D = {}, x = j.filter((s) => s._isLink && typeof s.options == "string" && s.cardinality ? (D[s.fieldname] = {
+      target: s.options,
+      cardinality: s.cardinality
+    }, !1) : !0).map((s) => {
+      if (!n.includeUnmappedMeta) {
+        const { _graphqlType: f, _unmapped: Se, _isLink: De, ...M } = s;
+        return Object.assign(M, { source: "introspected" });
+      }
+      const { _isLink: g, ...A } = s;
+      return Object.assign(A, { source: "introspected" });
+    }), F = {
+      name: c,
+      slug: h(c),
+      // oxlint-disable-next-line typescript/no-unsafe-type-assertion -- safe: heuristics always set a fieldtype default ('Data'); the optional fieldtype on GraphQLConversionFieldMeta is for intermediate processing, not because output fields lack fieldtype
+      fields: x
+    };
+    Object.keys(D).length > 0 && (F.links = D), n.includeUnmappedMeta && (F._graphqlTypeName = c), I.push(F);
+  }
+  return I;
+}
+function Te(t) {
+  return typeof t == "string" ? U(t) : q(t);
+}
+export {
+  ne as A,
+  V as B,
+  k as D,
+  Ce as F,
+  se as G,
+  ce as I,
+  J as S,
+  W as T,
+  Ie as V,
+  le as W,
+  Le as a,
+  R as b,
+  ie as c,
+  oe as d,
+  pe as e,
+  ae as f,
+  Ee as g,
+  he as h,
+  Pe as i,
+  ye as j,
+  me as k,
+  z as l,
+  _e as m,
+  Q as n,
+  je as o,
+  xe as p,
+  ve as q,
+  ke as r,
+  Me as s,
+  Ne as t,
+  re as u,
+  h as v,
+  Oe as w,
+  we as x
+};
+//# sourceMappingURL=index-D8R5ppAg.js.map