@stonecrop/schema 0.12.8 → 0.13.1

package/dist/converter/scalars.js

@@ -0,0 +1,86 @@
+/**
+ * GraphQL Scalar Type Mappings
+ *
+ * Maps standard GraphQL scalars and well-known custom scalars to Stonecrop field types.
+ * Source-agnostic — covers scalars commonly emitted by PostGraphile, Hasura, Apollo, etc.
+ *
+ * Users can extend these via the `customScalars` option in `GraphQLConversionOptions`.
+ *
+ * @packageDocumentation
+ */
+/**
+ * Mapping from standard GraphQL scalar types to Stonecrop field types.
+ * These are defined by the GraphQL specification and are always available.
+ *
+ * @public
+ */
+export const GQL_SCALAR_MAP = {
+    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' },
+};
+/**
+ * Mapping from well-known custom GraphQL scalars to Stonecrop field types.
+ * These cover scalars commonly used across GraphQL servers (PostGraphile, Hasura, etc.)
+ * without baking in knowledge of any specific server.
+ *
+ * Entries here have lower precedence than `customScalars` from options, but higher
+ * precedence than unknown/unmapped scalars.
+ *
+ * @public
+ */
+export const WELL_KNOWN_SCALARS = {
+    // 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' },
+};
+/**
+ * Set of scalar type names that are internal to GraphQL servers and should be skipped
+ * during field conversion (they don't represent meaningful data fields).
+ *
+ * @public
+ */
+export const INTERNAL_SCALARS = new Set(['Cursor']);
+/**
+ * Build a merged scalar map from the built-in maps and user-provided custom scalars.
+ * Precedence (highest to lowest): customScalars → GQL_SCALAR_MAP → WELL_KNOWN_SCALARS
+ *
+ * @param customScalars - User-provided scalar overrides
+ * @returns Merged scalar map
+ * @public
+ */
+export function buildScalarMap(customScalars) {
+    const merged = { ...WELL_KNOWN_SCALARS };
+    // Standard scalars override well-known
+    for (const [key, value] of Object.entries(GQL_SCALAR_MAP)) {
+        merged[key] = value;
+    }
+    // Custom scalars override everything
+    if (customScalars) {
+        for (const [key, value] of Object.entries(customScalars)) {
+            merged[key] = {
+                component: value.component ?? 'ATextInput',
+                fieldtype: value.fieldtype ?? 'Data',
+            };
+        }
+    }
+    return merged;
+}

package/dist/converter/types.js

@@ -0,0 +1,5 @@
+/**
+ * Types for the GraphQL introspection to Stonecrop schema converter.
+ * Source-agnostic — works with any GraphQL server (PostGraphile, Hasura, Apollo, etc.)
+ * @packageDocumentation
+ */

package/dist/converter-CYNFRwPg.js

@@ -0,0 +1,512 @@
+import { z as e } from "zod";
+import { buildClientSchema as t, buildSchema as n, isEnumType as r, isListType as i, isNonNullType as a, isObjectType as o, isScalarType as s } from "graphql";
+//#region src/fieldtype.ts
+var c = [
+	"Data",
+	"Text",
+	"Int",
+	"Float",
+	"Decimal",
+	"Check",
+	"Date",
+	"Time",
+	"Datetime",
+	"Duration",
+	"DateRange",
+	"JSON",
+	"Code",
+	"Link",
+	"Attach",
+	"Currency",
+	"Quantity",
+	"Select"
+], l = e.string().min(1).meta({
+	title: "StonecropFieldType",
+	description: "Semantic field types for Stonecrop doctypes, consistent across forms and tables"
+});
+function u(e) {
+	return c.includes(e);
+}
+var d = {
+	Data: {
+		component: "ATextInput",
+		fieldtype: "Data"
+	},
+	Text: {
+		component: "ATextInput",
+		fieldtype: "Text"
+	},
+	Int: {
+		component: "ANumericInput",
+		fieldtype: "Int"
+	},
+	Float: {
+		component: "ANumericInput",
+		fieldtype: "Float"
+	},
+	Decimal: {
+		component: "ADecimalInput",
+		fieldtype: "Decimal"
+	},
+	Check: {
+		component: "ACheckbox",
+		fieldtype: "Check"
+	},
+	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"
+	},
+	JSON: {
+		component: "ACodeEditor",
+		fieldtype: "JSON"
+	},
+	Code: {
+		component: "ACodeEditor",
+		fieldtype: "Code"
+	},
+	Link: {
+		component: "ALink",
+		fieldtype: "Link"
+	},
+	Attach: {
+		component: "AFileAttach",
+		fieldtype: "Attach"
+	},
+	Currency: {
+		component: "ACurrencyInput",
+		fieldtype: "Currency"
+	},
+	Quantity: {
+		component: "AQuantityInput",
+		fieldtype: "Quantity"
+	},
+	Select: {
+		component: "ADropdown",
+		fieldtype: "Select"
+	}
+};
+function f(e) {
+	return d[e]?.component ?? "ATextInput";
+}
+function p(e) {
+	return u(e) ? f(e) : "ATextInput";
+}
+//#endregion
+//#region src/field.ts
+var m = e.union([
+	e.string(),
+	e.array(e.string()),
+	e.record(e.string(), e.unknown())
+]).meta({
+	title: "FieldOptions",
+	description: "Field options - flexible bag for type-specific configuration"
+}), h = e.looseObject({ errorMessage: e.string() }).meta({
+	title: "FieldValidation",
+	description: "Validation configuration for form fields"
+}), g = e.object({
+	fieldname: e.string().min(1),
+	fieldtype: l,
+	component: e.string().optional(),
+	label: e.string().optional(),
+	width: e.string().optional(),
+	align: e.enum([
+		"left",
+		"center",
+		"right",
+		"start",
+		"end"
+	]).optional(),
+	required: e.boolean().optional(),
+	readOnly: e.boolean().optional(),
+	edit: e.boolean().optional(),
+	hidden: e.boolean().optional(),
+	value: e.unknown().optional(),
+	default: e.unknown().optional(),
+	options: m.optional(),
+	cardinality: e.enum([
+		"one",
+		"atMostOne",
+		"noneOrMany",
+		"atLeastOne"
+	]).optional(),
+	mask: e.string().optional(),
+	validation: h.optional()
+}).meta({
+	title: "FieldMeta",
+	description: "Unified field metadata - the single source of truth for field definitions, works for both forms (AForm) and tables (ATable)"
+}), _ = e.enum([
+	"atMostOne",
+	"one",
+	"noneOrMany",
+	"atLeastOne"
+]).meta({
+	title: "Cardinality",
+	description: "Cardinality for relationship links between doctypes"
+}), v = e.object({
+	method: e.literal("sync"),
+	limit: e.number().int().positive().optional()
+}).meta({
+	title: "SyncFetch",
+	description: "Sync fetch strategy - data is fetched in the initial query"
+}), y = e.object({ method: e.literal("lazy") }).meta({
+	title: "LazyFetch",
+	description: "Lazy fetch strategy - data is fetched on demand in a separate query"
+}), b = e.object({
+	method: e.literal("custom"),
+	handler: e.string()
+}).meta({
+	title: "CustomFetch",
+	description: "Custom fetch strategy - uses a custom handler function"
+}), x = e.discriminatedUnion("method", [
+	v,
+	y,
+	b
+]).meta({
+	title: "FetchStrategy",
+	description: "Fetch strategy for link data loading"
+}), S = e.object({
+	target: e.string().min(1),
+	cardinality: _,
+	backlink: e.string().optional(),
+	component: e.string().optional(),
+	fieldname: e.string().min(1).optional(),
+	fetch: x.optional(),
+	blockWorkflows: e.boolean().optional()
+}).meta({
+	title: "LinkDeclaration",
+	description: "Declares a relationship from one doctype to another"
+}), C = e.object({
+	label: e.string().min(1),
+	handler: e.string().min(1),
+	requiredFields: e.array(e.string()).optional(),
+	allowedStates: e.array(e.string()).optional(),
+	confirm: e.boolean().optional(),
+	args: e.record(e.string(), e.unknown()).optional()
+}).meta({
+	title: "ActionDefinition",
+	description: "Action definition within a workflow"
+}), w = e.object({
+	states: e.array(e.string()).optional(),
+	actions: e.record(e.string(), C).optional()
+}).meta({
+	title: "WorkflowMeta",
+	description: "Workflow metadata - states and actions for a doctype"
+}), T = e.object({
+	name: e.string().min(1),
+	slug: e.string().min(1).optional(),
+	tableName: e.string().optional(),
+	fields: e.array(g),
+	links: e.record(e.string(), S).optional(),
+	workflow: w.optional(),
+	inherits: e.string().optional()
+}).meta({
+	title: "DoctypeMeta",
+	description: "Doctype metadata - complete definition of a doctype"
+});
+//#endregion
+//#region src/validation.ts
+function E(e) {
+	let t = g.safeParse(e);
+	return t.success ? {
+		success: !0,
+		errors: []
+	} : {
+		success: !1,
+		errors: t.error.issues.map((e) => ({
+			path: e.path,
+			message: e.message
+		}))
+	};
+}
+function D(e) {
+	let t = T.safeParse(e);
+	return t.success ? {
+		success: !0,
+		errors: []
+	} : {
+		success: !1,
+		errors: t.error.issues.map((e) => ({
+			path: e.path,
+			message: e.message
+		}))
+	};
+}
+function O(e) {
+	return g.parse(e);
+}
+function k(e) {
+	return T.parse(e);
+}
+//#endregion
+//#region src/naming.ts
+function A(e) {
+	return e.replace(/_([a-z])/g, (e, t) => t.toUpperCase());
+}
+function j(e) {
+	return e.replace(/[A-Z]/g, (e) => `_${e.toLowerCase()}`);
+}
+function M(e) {
+	return e.split("_").map((e) => e.charAt(0).toUpperCase() + e.slice(1).toLowerCase()).join(" ");
+}
+function N(e) {
+	let t = e.replace(/([A-Z])/g, " $1").trim();
+	return t.charAt(0).toUpperCase() + t.slice(1);
+}
+function P(e) {
+	return e.split(/[-_\s]+/).map((e) => e.charAt(0).toUpperCase() + e.slice(1).toLowerCase()).join("");
+}
+function F(e) {
+	return e.replace(/([a-z])([A-Z])/g, "$1-$2").replace(/[\s_]+/g, "-").toLowerCase();
+}
+function I(e) {
+	return e.replace(/([a-z])([A-Z])/g, "$1_$2").replace(/[\s-]+/g, "_").toLowerCase();
+}
+//#endregion
+//#region src/converter/scalars.ts
+var L = {
+	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"
+	}
+}, R = {
+	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"
+	},
+	UUID: {
+		component: "ATextInput",
+		fieldtype: "Data"
+	},
+	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"
+	},
+	JSON: {
+		component: "ACodeEditor",
+		fieldtype: "JSON"
+	},
+	JSONObject: {
+		component: "ACodeEditor",
+		fieldtype: "JSON"
+	},
+	JsonNode: {
+		component: "ACodeEditor",
+		fieldtype: "JSON"
+	}
+}, z = new Set(["Cursor"]);
+function B(e) {
+	let t = { ...R };
+	for (let [e, n] of Object.entries(L)) t[e] = n;
+	if (e) for (let [n, r] of Object.entries(e)) t[n] = {
+		component: r.component ?? "ATextInput",
+		fieldtype: r.fieldtype ?? "Data"
+	};
+	return t;
+}
+//#endregion
+//#region src/converter/heuristics.ts
+var V = [
+	"Connection",
+	"Edge",
+	"Input",
+	"Patch",
+	"Payload",
+	"Condition",
+	"Filter",
+	"OrderBy",
+	"Aggregate",
+	"AggregateResult",
+	"AggregateFilter",
+	"DeleteResponse",
+	"InsertResponse",
+	"UpdateResponse",
+	"MutationResponse"
+], H = new Set([
+	"Query",
+	"Mutation",
+	"Subscription"
+]);
+function U(e, t) {
+	if (e.startsWith("__") || H.has(e) || e === "Node") return !1;
+	for (let t of V) if (e.endsWith(t)) return !1;
+	let n = t.getFields();
+	return Object.keys(n).length !== 0;
+}
+var W = new Set([
+	"nodeId",
+	"__typename",
+	"clientMutationId"
+]);
+function G(e, t, n) {
+	return !W.has(e);
+}
+function K(e) {
+	let t = !1, n = !1, r = e;
+	return a(r) && (t = !0, r = r.ofType), i(r) && (n = !0, r = r.ofType, a(r) && (r = r.ofType)), {
+		namedType: r,
+		required: t,
+		isList: n
+	};
+}
+function q(e) {
+	let t = e.getFields().edges;
+	if (!t) return;
+	let { namedType: n, isList: r } = K(t.type);
+	if (!r || !o(n)) return;
+	let i = n.getFields().node;
+	if (!i) return;
+	let { namedType: a } = K(i.type);
+	if (o(a)) return a.name;
+}
+function J(e, t, n, i = {}) {
+	let { namedType: a, required: c, isList: l } = K(t.type), u = B(i.customScalars), d = {
+		fieldname: e,
+		label: N(e),
+		component: "ATextInput",
+		fieldtype: "Data"
+	};
+	if (c && (d.required = !0), s(a)) {
+		if (z.has(a.name)) return d._unmapped = !0, i.includeUnmappedMeta && (d._graphqlType = a.name), d;
+		let e = u[a.name];
+		return e ? (d.component = e.component, d.fieldtype = e.fieldtype) : (d._unmapped = !0, i.includeUnmappedMeta && (d._graphqlType = a.name)), d;
+	}
+	if (r(a)) return d.component = "ADropdown", d.fieldtype = "Select", d.options = a.getValues().map((e) => e.name), d;
+	if (o(a)) {
+		if (!l && n.has(a.name)) return d.component = "ALink", d.fieldtype = "Link", d.options = F(a.name), d;
+		let e = q(a);
+		return e && n.has(e) ? (d.component = "ATable", d._isLink = !0, d.options = F(e), d.cardinality = "noneOrMany", delete d.fieldtype, d) : l && n.has(a.name) ? (d.component = "ATable", d._isLink = !0, d.options = F(a.name), d.cardinality = "noneOrMany", delete d.fieldtype, d) : (d._unmapped = !0, i.includeUnmappedMeta && (d._graphqlType = a.name), d);
+	}
+	return d._unmapped = !0, i.includeUnmappedMeta && (d._graphqlType = a.name), d;
+}
+//#endregion
+//#region src/converter/index.ts
+function Y(e, t = {}) {
+	let n = X(e), r = n.getTypeMap(), i = /* @__PURE__ */ new Set(), a = n.getQueryType(), s = n.getMutationType(), c = n.getSubscriptionType();
+	a && i.add(a.name), s && i.add(s.name), c && i.add(c.name);
+	let l = t.isEntityType ?? U, u = /* @__PURE__ */ new Set();
+	for (let [e, t] of Object.entries(r)) o(t) && (i.has(e) || l(e, t) && u.add(e));
+	let d = u;
+	if (t.include) {
+		let e = new Set(t.include);
+		d = new Set([...u].filter((t) => e.has(t)));
+	}
+	if (t.exclude) {
+		let e = new Set(t.exclude);
+		d = new Set([...d].filter((t) => !e.has(t)));
+	}
+	let f = t.isEntityField ?? G, p = t.deriveTableName ?? ((e) => I(e)), m = [];
+	for (let e of d) {
+		let n = r[e];
+		if (!o(n)) continue;
+		let i = n.getFields(), a = t.typeOverrides?.[e], s = Object.entries(i).filter(([e, t]) => f(e, t, n)).map(([e, r]) => {
+			if (t.classifyField) {
+				let i = t.classifyField(e, r, n);
+				if (i != null) return {
+					fieldname: e,
+					label: i.label ?? e,
+					component: i.component ?? "ATextInput",
+					fieldtype: i.fieldtype ?? "Data",
+					...i
+				};
+			}
+			let i = J(e, r, u, t);
+			return a?.[e] ? {
+				...i,
+				...a[e]
+			} : i;
+		}), c = {}, l = s.filter((e) => e._isLink && typeof e.options == "string" && e.cardinality ? (c[e.fieldname] = {
+			target: e.options,
+			cardinality: e.cardinality
+		}, !1) : !0).map((e) => {
+			if (!t.includeUnmappedMeta) {
+				let { _graphqlType: t, _unmapped: n, _isLink: r, ...i } = e;
+				return i;
+			}
+			let { _isLink: n, ...r } = e;
+			return r;
+		}), d = {
+			name: e,
+			slug: F(e),
+			fields: l
+		};
+		Object.keys(c).length > 0 && (d.links = c);
+		let h = p(e);
+		h && (d.tableName = h), t.includeUnmappedMeta && (d._graphqlTypeName = e), m.push(d);
+	}
+	return m;
+}
+function X(e) {
+	return typeof e == "string" ? n(e) : t(e);
+}
+//#endregion
+export { f as C, d as S, p as T, O as _, L as a, c as b, B as c, I as d, A as f, k as g, F as h, U as i, N as l, P as m, J as n, z as o, M as p, G as r, R as s, Y as t, j as u, D as v, u as w, l as x, E as y };
+
+//# sourceMappingURL=converter-CYNFRwPg.js.map