@jigs.design/server 0.0.0-stage → 0.1.0

package/dist/outputs.js

@@ -0,0 +1,120 @@
+import { branches, objectFields } from "./inputs.js";
+import { ELEMENT, columnAt, lineAt, nearest } from "@jigs.design/compiler";
+import { dataSchema } from "@jigs.design/host";
+import { z } from "zod";
+//#region src/outputs.ts
+const jsonSchemas = /* @__PURE__ */ new WeakMap();
+/** The JSON Schema of an output schema, as output; null when it has none. */
+function jsonSchemaOf(schema) {
+	const cached = jsonSchemas.get(schema);
+	if (cached !== void 0) return cached;
+	let converted;
+	try {
+		converted = z.toJSONSchema(schema, { io: "output" });
+	} catch {
+		converted = null;
+	}
+	jsonSchemas.set(schema, converted);
+	return converted;
+}
+/** `node`, or what its `$ref` names in `root`'s definitions. */
+function resolve(node, root) {
+	if (node.$ref === void 0) return node;
+	if (node.$ref === "#") return root;
+	const name = /^#\/\$defs\/(.+)$/.exec(node.$ref)?.[1];
+	return name === void 0 ? null : root.$defs?.[name] ?? null;
+}
+/** What each element of the arrays `nodes` describe is; null when one of them is not such an array. */
+function elements(nodes, root) {
+	const next = [];
+	for (const node of nodes) for (const raw of branches(node)) {
+		const branch = resolve(raw, root);
+		if (branch === null || branch.oneOf !== void 0 || branch.allOf !== void 0) return null;
+		if (branch.anyOf !== void 0 || branch.type === "null") continue;
+		const { items } = branch;
+		if (items === void 0 || items === true || items === false || Array.isArray(items)) return null;
+		next.push(items);
+	}
+	return next.length === 0 ? null : next;
+}
+/**
+* The first field of `path` that the data `root` describes cannot have.
+* An `ELEMENT` step goes into an array's items. Null when every field is
+* there, or when the walk reaches something it cannot check: a value with
+* no schema, an open object, an array or a string (whose fields are
+* methods), or a combinator other than `anyOf`.
+*/
+function missingField(root, path) {
+	let nodes = [root];
+	for (const [index, name] of path.entries()) {
+		if (name === ELEMENT) {
+			const items = elements(nodes, root);
+			if (items === null) return null;
+			nodes = items;
+			continue;
+		}
+		const next = [];
+		const fields = /* @__PURE__ */ new Set();
+		for (const node of nodes) for (const raw of branches(node)) {
+			const branch = resolve(raw, root);
+			if (branch === null || branch.oneOf !== void 0 || branch.allOf !== void 0) return null;
+			if (branch.anyOf !== void 0 || branch.type === "null") continue;
+			const object = objectFields(branch);
+			if (object === null) return null;
+			const field = object.fields.get(name);
+			if (field !== void 0) next.push(field);
+			else if (object.open) return null;
+			else for (const key of object.fields.keys()) fields.add(key);
+		}
+		if (next.length === 0) return fields.size === 0 ? null : {
+			fields: [...fields],
+			index
+		};
+		nodes = next;
+	}
+	return null;
+}
+/** How the read up to `path[index]` is written, for a message. */
+function writtenRead(read, index) {
+	if (read.item === void 0) return `\`${[read.data, ...read.path.slice(0, index)].join(".")}\``;
+	const { name } = read.item;
+	const fields = read.path.slice(read.item.steps, index);
+	const list = `\`${read.item.list}\``;
+	return fields.length === 0 ? `\`${name}\` (an item of ${list})` : `\`${[name, ...fields].join(".")}\` (\`${name}\` is an item of ${list})`;
+}
+/** The longest field list a message spells out. */
+const MAX_LISTED_FIELDS = 12;
+/**
+* Reads of a procedure's data, such as `orders.data.totl`, through a field
+* its output schema does not have. Each is an error: the read is undefined,
+* and a read through it throws.
+*/
+function outputDiagnostics(host, source, reads) {
+	const diagnostics = [];
+	for (const read of reads) {
+		const procedure = Object.hasOwn(host.procedures, read.procedure) ? host.procedures[read.procedure] : void 0;
+		const data = procedure === void 0 ? void 0 : dataSchema(procedure);
+		const output = data === void 0 ? null : jsonSchemaOf(data);
+		const missing = output === null ? null : missingField(output, read.path);
+		const place = missing === null ? void 0 : read.places[missing.index];
+		if (missing === null || place === void 0 || place === null) continue;
+		const name = read.path[missing.index] ?? "";
+		const written = writtenRead(read, missing.index);
+		const near = nearest(name, missing.fields, 1)[0];
+		const hint = near !== void 0 ? `; did you mean ${near}?` : missing.fields.length <= MAX_LISTED_FIELDS ? `; it has ${missing.fields.join(", ")}` : "";
+		diagnostics.push({
+			code: "procedure_output",
+			message: `${written} has no field "${name}"${hint}`,
+			severity: "error",
+			span: place.start === void 0 || place.end === void 0 ? { line: place.line } : {
+				column: columnAt(source, place.start),
+				end: place.end,
+				line: lineAt(source, place.start),
+				start: place.start
+			}
+		});
+	}
+	return diagnostics;
+}
+//#endregion
+export { outputDiagnostics };

package/dist/pragma.js

@@ -0,0 +1,80 @@
+const PRAGMA = /^\{@pickle\s+(\d+)(?:\s+catalog=(\d+))?\}[ \t]*(?:\r?\n|$)/;
+/** Splits a leading `{@pickle 0 catalog=1}` line from the body. */
+function splitPragma(source) {
+	const match = PRAGMA.exec(source);
+	if (match === null) return {
+		body: source,
+		versions: null
+	};
+	const catalog = match[2] === void 0 ? null : Number(match[2]);
+	return {
+		body: source.slice(match[0].length),
+		versions: {
+			catalog,
+			language: Number(match[1])
+		}
+	};
+}
+/**
+* What a stored spec's pragma says about where it came from. Nothing is
+* migrated yet: the catalog has no deprecation entries until the v2
+* compiler, so a mismatch is only reported.
+*/
+function versionDiagnostics(versions, catalogVersion) {
+	if (versions === null) return [];
+	const diagnostics = [];
+	if (versions.language > 0) diagnostics.push({
+		code: "language_version",
+		message: `This spec was written for language version ${versions.language}; this server checks version 0`,
+		severity: "warning",
+		span: { line: 1 }
+	});
+	if (versions.catalog !== null && versions.catalog !== catalogVersion) diagnostics.push({
+		code: "catalog_version",
+		message: versions.catalog > catalogVersion ? `This spec was written for catalog version ${versions.catalog}, newer than this server's ${catalogVersion}; components or props added since are dropped` : `This spec was written for catalog version ${versions.catalog} and was checked against version ${catalogVersion}`,
+		severity: versions.catalog > catalogVersion ? "warning" : "info",
+		span: { line: 1 }
+	});
+	return diagnostics;
+}
+/** The pragma line `withPragma` puts above a body, with its line break. */
+function pragmaLine(catalogVersion) {
+	return `{@pickle 0 catalog=${catalogVersion}}\n`;
+}
+/** `body` with a pragma naming the versions it was checked against. */
+function withPragma(body, catalogVersion) {
+	return `${pragmaLine(catalogVersion)}${body}`;
+}
+/**
+* `items` with their spans moved past `prefix`, the text a source has above
+* the body they were reported on: lines by its line breaks, offsets by its
+* length. `prefix` ends in a line break, so columns stay.
+*/
+function belowPrefix(items, prefix) {
+	const lines = prefix.split("\n").length - 1;
+	const shift = (span) => span.start === void 0 || span.end === void 0 ? {
+		...span,
+		line: span.line + lines
+	} : {
+		...span,
+		end: span.end + prefix.length,
+		line: span.line + lines,
+		start: span.start + prefix.length
+	};
+	return items.map((item) => {
+		const moved = {
+			...item,
+			span: shift(item.span)
+		};
+		if (item.fix !== void 0) moved.fix = {
+			edits: item.fix.edits.map((edit) => ({
+				span: shift(edit.span),
+				text: edit.text
+			})),
+			title: item.fix.title
+		};
+		return moved;
+	});
+}
+//#endregion
+export { belowPrefix, pragmaLine, splitPragma, versionDiagnostics, withPragma };

package/dist/rewrite.js

@@ -0,0 +1,30 @@
+import { hoistDeclarations } from "@jigs.design/compiler";
+import { needsRepair } from "@jigs.design/prompt";
+//#region src/rewrite.ts
+/**
+* When the only errors in `body` are markup that reads names `{@body}` lines
+* below it declare, `body` with its top-level `{@body}` lines moved to the
+* top, compiled, instead of a repair round. A finished document already runs
+* every declaration before it renders, so the program is the same; the
+* diagnostic is about the page while it streams in, which the stored source
+* fixes for the next turn. Null when anything else is wrong, or the moved
+* source still needs a repair.
+*/
+function reorderDeclarations(body, compiled, compile) {
+	const errors = compiled.diagnostics.filter((diagnostic) => diagnostic.severity === "error");
+	if (errors.length === 0 || errors.some((diagnostic) => diagnostic.code !== "use_before_declare")) return null;
+	const hoisted = hoistDeclarations(body);
+	if (hoisted === null) return null;
+	const recompiled = compile(hoisted.text);
+	if (needsRepair(recompiled.diagnostics)) return null;
+	return {
+		body: hoisted.text,
+		compiled: recompiled,
+		rewrite: {
+			code: "use_before_declare",
+			moved: hoisted.moved
+		}
+	};
+}
+//#endregion
+export { reorderDeclarations };

package/dist/server.d.ts

@@ -0,0 +1,17 @@
+import { ContextFunction, PickleServer, PickleServerOptions, RunFunctions } from "./types.js";
+import { Catalog, Procedures } from "@jigs.design/host";
+//#region src/server.d.ts
+/**
+ * Types a `context` and `run` pair outside `createPickleServer`, so two
+ * servers (one per platform) can share them. `TContext` comes from `context`
+ * alone, as in `createPickleServer`.
+ */
+export declare function defineRun<const TProcedures extends Procedures, TContext = any>(procedures: TProcedures, handlers: {
+  context: ContextFunction<TContext>;
+  run: RunFunctions<NoInfer<TProcedures>, NoInfer<TContext>>;
+}): {
+  context: ContextFunction<TContext>;
+  run: RunFunctions<TProcedures, TContext>;
+};
+export declare function createPickleServer<const TProcedures extends Procedures, const TCatalog extends Catalog, TContext = any, TOptions = undefined, const TSpecName extends string = never>(options: PickleServerOptions<TProcedures, TCatalog, TContext, TOptions, TSpecName>): PickleServer<TContext, TSpecName>;
+//#endregion