@stonecrop/schema 0.13.12 → 0.14.0

package/dist/index-C8F23K8c.js

@@ -0,0 +1,555 @@
+import { z as e } from "zod";
+import { isScalarType as M, isEnumType as E, isObjectType as T, isNonNullType as L, isListType as v, isNamedType as U, buildSchema as P, 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
+], W = e.string().min(1).meta({
+  title: "StonecropFieldType",
+  description: "Semantic field types for Stonecrop doctypes, consistent across forms and tables"
+});
+function J(t) {
+  return V.includes(t);
+}
+const z = {
+  // Text
+  Data: { component: "ATextInput", fieldtype: "Data" },
+  Text: { component: "ATextarea", fieldtype: "Text" },
+  // Numeric — all numeric variants render with ANumericInput; display differences (currency,
+  // precision, unit) are carried by `format`/`mask`, not a distinct component.
+  Int: { component: "ANumericInput", fieldtype: "Int" },
+  Float: { component: "ANumericInput", fieldtype: "Float" },
+  Decimal: { component: "ANumericInput", fieldtype: "Decimal" },
+  // Boolean
+  Check: { component: "ACheckbox", fieldtype: "Check" },
+  // Date/Time — no dedicated Time SFC exists; Time falls back to a plain text input.
+  Date: { component: "ADate", fieldtype: "Date" },
+  Time: { component: "ATextInput", fieldtype: "Time" },
+  Datetime: { component: "ADateTime", fieldtype: "Datetime" },
+  Duration: { component: "ADuration", fieldtype: "Duration" },
+  DateRange: { component: "ADateRange", fieldtype: "DateRange" },
+  // Structured — JSON vs Code is disambiguated by the field's `language`, not the component.
+  JSON: { component: "ACodeEditor", fieldtype: "JSON" },
+  Code: { component: "ACodeEditor", fieldtype: "Code" },
+  // Relational
+  Link: { component: "AFormLink", fieldtype: "Link" },
+  // Files
+  Attach: { component: "AFileAttach", fieldtype: "Attach" },
+  // Specialized — Currency/Quantity are numeric with a display format.
+  Currency: { component: "ANumericInput", fieldtype: "Currency" },
+  Quantity: { component: "ANumericInput", 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 Q(t) {
+  return z[t]?.component ?? "ATextInput";
+}
+function Ie(t) {
+  return J(t) ? Q(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"
+}), K = e.looseObject({
+  /** Error message to display when validation fails */
+  errorMessage: e.string()
+}).meta({
+  title: "FieldValidation",
+  description: "Validation configuration for form fields"
+});
+function $(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 G() {
+  const t = e.object({
+    kind: e.literal("field"),
+    fieldname: e.string().min(1),
+    fieldtype: W.optional(),
+    component: e.string().optional(),
+    primaryKey: e.boolean().optional(),
+    computed: e.boolean().optional(),
+    language: 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: K.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($, r), { ValueFieldSchema: t, TableFieldSchema: n, FieldsetFieldSchema: a, DoctypeFieldSchema: o };
+}
+const F = G(), Ce = F.ValueFieldSchema, Le = F.FieldsetFieldSchema, _e = F.TableFieldSchema, k = F.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 stateless command actions with no workflow effect at all (print, email, etc.) */
+  stateless: e.boolean().optional(),
+  /**
+   * True for an internal self-transition: the action runs within the current state without
+   * advancing the workflow (e.g. `save`, which mutates record data but stays put). Scoped by
+   * `allowedStates`, rendered as a self-loop in the graph, and has no `nextState`. Distinct from
+   * `stateless` (which has no workflow presence at all): a self-transition is graph-owned and,
+   * unlike a stateless command, persists record data on dispatch.
+   */
+  selfTransition: 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 we(t, n) {
+  const o = t.allowedStates;
+  return !o || o.length === 0 ? !0 : o.includes(n);
+}
+const oe = e.record(
+  e.string(),
+  e.object({
+    position: e.object({ x: e.number(), y: e.number() }).optional(),
+    targetPosition: e.enum(["left", "top", "right", "bottom"]).optional(),
+    sourcePosition: e.enum(["left", "top", "right", "bottom"]).optional()
+  })
+), ae = 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(),
+  /**
+   * DocBuilder node positions keyed by state name — authoring view-state. Persisted here so a
+   * doctype author's manual graph arrangement survives reloads; like `triggers`, it is client-only
+   * and never enters the runtime GraphQL SDL. See {@link (WorkflowLayout:variable)}.
+   */
+  layout: oe.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: ae.optional(),
+  /** Parent doctype for inheritance */
+  inherits: e.string().optional()
+}).meta({
+  title: "DoctypeMeta",
+  description: "Doctype metadata - complete definition of a doctype"
+});
+function Oe(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 je(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 xe(t) {
+  return k.parse(t);
+}
+function Ne(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 ve(t) {
+  return t.split("_").map((n) => n.charAt(0).toUpperCase() + n.slice(1).toLowerCase()).join(" ");
+}
+function re(t) {
+  const n = t.replace(/([A-Z])/g, " $1").trim();
+  return n.charAt(0).toUpperCase() + n.slice(1);
+}
+function le(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 Ue(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" }
+}, ce = {
+  // Arbitrary precision / large numbers — all numeric variants render with ANumericInput.
+  BigFloat: { component: "ANumericInput", fieldtype: "Decimal" },
+  BigDecimal: { component: "ANumericInput", fieldtype: "Decimal" },
+  Decimal: { component: "ANumericInput", fieldtype: "Decimal" },
+  BigInt: { component: "ANumericInput", fieldtype: "Int" },
+  Long: { component: "ANumericInput", fieldtype: "Int" },
+  // Identifiers
+  UUID: { component: "ATextInput", fieldtype: "Data" },
+  // Date / Time — no dedicated Time SFC exists; Time falls back to a plain text input.
+  DateTime: { component: "ADateTime", fieldtype: "Datetime" },
+  Datetime: { component: "ADateTime", fieldtype: "Datetime" },
+  Date: { component: "ADate", fieldtype: "Date" },
+  Time: { component: "ATextInput", fieldtype: "Time" },
+  Interval: { component: "ADuration", fieldtype: "Duration" },
+  Duration: { component: "ADuration", fieldtype: "Duration" },
+  // Structured data
+  JSON: { component: "ACodeEditor", fieldtype: "JSON" },
+  JSONObject: { component: "ACodeEditor", fieldtype: "JSON" },
+  JsonNode: { component: "ACodeEditor", fieldtype: "JSON" }
+}, pe = /* @__PURE__ */ new Set(["Cursor"]);
+function de(t) {
+  const n = { ...ce };
+  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 ue = [
+  "Connection",
+  "Edge",
+  "Input",
+  "Patch",
+  "Payload",
+  "Condition",
+  "Filter",
+  "OrderBy",
+  "Aggregate",
+  "AggregateResult",
+  "AggregateFilter",
+  "DeleteResponse",
+  "InsertResponse",
+  "UpdateResponse",
+  "MutationResponse"
+], me = /* @__PURE__ */ new Set(["Query", "Mutation", "Subscription"]);
+function fe(t, n) {
+  if (t.startsWith("__") || me.has(t) || t === "Node")
+    return !1;
+  for (const a of ue)
+    if (t.endsWith(a))
+      return !1;
+  const o = n.getFields();
+  return Object.keys(o).length !== 0;
+}
+const ye = /* @__PURE__ */ new Set(["nodeId", "__typename", "clientMutationId"]);
+function ge(t, n, o) {
+  return !ye.has(t);
+}
+function D(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)), !U(a))
+    throw new Error(`Expected a named GraphQL type, got: ${String(a)}`);
+  return { namedType: a, required: n, isList: o };
+}
+function he(t) {
+  const o = t.getFields().edges;
+  if (!o) return;
+  const { namedType: a, isList: r } = D(o.type);
+  if (!r || !T(a)) return;
+  const d = a.getFields().node;
+  if (!d) return;
+  const { namedType: u } = D(d.type);
+  if (T(u))
+    return u.name;
+}
+function Te(t, n, o, a = {}) {
+  const { namedType: r, required: y, isList: d } = D(n.type), u = de(a.customScalars), i = {
+    kind: "field",
+    fieldname: t,
+    label: re(t),
+    component: "ATextInput",
+    fieldtype: "Data"
+  };
+  if (y && (i.required = !0), M(r)) {
+    if (pe.has(r.name))
+      return i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name), i;
+    if (r.name === "ID") {
+      const m = le(t);
+      if (o.has(m))
+        return i.component = "AFormLink", i.fieldtype = "Link", i.options = h(m), i;
+    }
+    const s = u[r.name];
+    return s ? (i.component = s.component, i.fieldtype = s.fieldtype) : (i._unmapped = !0, a.includeUnmappedMeta && (i._graphqlType = r.name)), i;
+  }
+  if (E(r))
+    return i.component = "ADropdown", i.fieldtype = "Select", i.options = r.getValues().map((s) => s.name), i;
+  if (T(r)) {
+    if (!d && o.has(r.name))
+      return i.component = "AFormLink", i.fieldtype = "Link", i.options = h(r.name), i;
+    const s = he(r);
+    return s && o.has(s) ? (i.component = "ATable", i._isLink = !0, i.options = h(s), 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 = be(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 ?? fe, s = /* @__PURE__ */ new Set();
+  for (const [c, p] of Object.entries(a))
+    T(p) && (r.has(c) || i(c, p) && s.add(c));
+  let m = s;
+  if (n.include) {
+    const c = new Set(n.include);
+    m = new Set([...s].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 ?? ge, 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(([l, g]) => w(l, g, p)).map(([l, g]) => {
+      if (n.classifyField) {
+        const f = n.classifyField(l, g, p);
+        if (f != null)
+          return {
+            kind: "field",
+            fieldname: l,
+            label: f.label ?? l,
+            component: f.component ?? "ATextInput",
+            fieldtype: f.fieldtype ?? "Data",
+            ...f
+          };
+      }
+      const b = Te(l, g, s, n);
+      return C?.[l] ? Object.assign(b, C[l]) : b;
+    }), A = {}, x = j.filter((l) => l._isLink && typeof l.options == "string" && l.cardinality ? (A[l.fieldname] = {
+      target: l.options,
+      cardinality: l.cardinality
+    }, !1) : !0).map((l) => {
+      if (!n.includeUnmappedMeta) {
+        const { _graphqlType: f, _unmapped: Ae, _isLink: Se, ...N } = l;
+        return Object.assign(N, { source: "introspected" });
+      }
+      const { _isLink: g, ...b } = l;
+      return Object.assign(b, { source: "introspected" });
+    }), S = {
+      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(A).length > 0 && (S.links = A), n.includeUnmappedMeta && (S._graphqlTypeName = c), I.push(S);
+  }
+  return I;
+}
+function be(t) {
+  return typeof t == "string" ? P(t) : q(t);
+}
+export {
+  ne as A,
+  V as B,
+  k as D,
+  Le as F,
+  se as G,
+  pe as I,
+  W as S,
+  z as T,
+  Ce as V,
+  ce as W,
+  _e as a,
+  R as b,
+  ie as c,
+  oe as d,
+  ae as e,
+  de as f,
+  re as g,
+  Ee as h,
+  Te as i,
+  Pe as j,
+  ge as k,
+  fe as l,
+  Q as m,
+  we as n,
+  J as o,
+  Ne as p,
+  xe as q,
+  Ue as r,
+  Ie as s,
+  Me as t,
+  ve as u,
+  le as v,
+  h as w,
+  je as x,
+  Oe as y
+};
+//# sourceMappingURL=index-C8F23K8c.js.map