@soda-gql/runtime 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Shota Hatada
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,308 @@
+
+//#region packages/core/src/types/fragment/var-ref.ts
+/** Nominal reference used to defer variable binding while carrying type info. */
+var VarRef = class VarRef {
+	constructor(name) {
+		this.name = name;
+	}
+	static create(name) {
+		return new VarRef(name);
+	}
+};
+
+//#endregion
+//#region packages/core/src/utils/map-values.ts
+const mapValues = (obj, fn) => Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
+
+//#endregion
+//#region packages/core/src/composer/input.ts
+const createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => VarRef.create(name));
+
+//#endregion
+//#region packages/core/src/types/runtime/projection.ts
+/**
+* Nominal type representing any slice selection regardless of schema specifics.
+* Encodes how individual slices map a concrete field path to a projection
+* function. Multiple selections allow slices to expose several derived values.
+*/
+var Projection = class {
+	constructor(paths, projector) {
+		this.projector = projector;
+		this.paths = paths.map((path) => createProjectionPath(path));
+	}
+	paths;
+};
+function createProjectionPath(path) {
+	const segments = path.split(".");
+	if (path === "$" || segments.length <= 1) throw new Error("Field path must not be only $ or empty");
+	return {
+		full: path,
+		segments: segments.slice(1)
+	};
+}
+
+//#endregion
+//#region packages/core/src/types/runtime/sliced-execution-result.ts
+/** Runtime guard interface shared by all slice result variants. */
+var SlicedExecutionResultGuards = class {
+	isSuccess() {
+		return this.type === "success";
+	}
+	isError() {
+		return this.type === "error";
+	}
+	isEmpty() {
+		return this.type === "empty";
+	}
+	constructor(type) {
+		this.type = type;
+	}
+};
+/** Variant representing an empty payload (no data, no error). */
+var SlicedExecutionResultEmpty = class extends SlicedExecutionResultGuards {
+	constructor() {
+		super("empty");
+	}
+	unwrap() {
+		return null;
+	}
+	safeUnwrap() {
+		return {
+			data: void 0,
+			error: void 0
+		};
+	}
+};
+/** Variant representing a successful payload. */
+var SlicedExecutionResultSuccess = class extends SlicedExecutionResultGuards {
+	constructor(data, extensions) {
+		super("success");
+		this.data = data;
+		this.extensions = extensions;
+	}
+	unwrap() {
+		return this.data;
+	}
+	safeUnwrap(transform) {
+		return {
+			data: transform(this.data),
+			error: void 0
+		};
+	}
+};
+/** Variant representing an error payload created by the adapter. */
+var SlicedExecutionResultError = class extends SlicedExecutionResultGuards {
+	constructor(error, extensions) {
+		super("error");
+		this.error = error;
+		this.extensions = extensions;
+	}
+	unwrap() {
+		throw this.error;
+	}
+	safeUnwrap() {
+		return {
+			data: void 0,
+			error: this.error
+		};
+	}
+};
+
+//#endregion
+//#region packages/core/src/runtime/parse-execution-result.ts
+function* generateErrorMapEntries(errors, projectionPathGraph) {
+	for (const error of errors) {
+		const errorPath = error.path ?? [];
+		let stack = projectionPathGraph;
+		for (let i = 0; i <= errorPath.length; i++) {
+			const segment = errorPath[i];
+			if (segment == null || typeof segment === "number") {
+				yield* stack.matches.map(({ label, path }) => ({
+					label,
+					path,
+					error
+				}));
+				break;
+			}
+			yield* stack.matches.filter(({ exact }) => exact).map(({ label, path }) => ({
+				label,
+				path,
+				error
+			}));
+			const next = stack.children[segment];
+			if (!next) break;
+			stack = next;
+		}
+	}
+}
+const createErrorMaps = (errors, projectionPathGraph) => {
+	const errorMaps = {};
+	for (const { label, path, error } of generateErrorMapEntries(errors ?? [], projectionPathGraph)) {
+		const mapPerLabel = errorMaps[label] || (errorMaps[label] = {});
+		(mapPerLabel[path] || (mapPerLabel[path] = [])).push({ error });
+	}
+	return errorMaps;
+};
+const accessDataByPathSegments = (data, pathSegments) => {
+	let current = data;
+	for (const segment of pathSegments) {
+		if (current == null) return { error: /* @__PURE__ */ new Error("No data") };
+		if (typeof current !== "object") return { error: /* @__PURE__ */ new Error("Incorrect data type") };
+		if (Array.isArray(current)) return { error: /* @__PURE__ */ new Error("Incorrect data type") };
+		current = current[segment];
+	}
+	return { data: current };
+};
+const createExecutionResultParser = ({ fragments, projectionPathGraph }) => {
+	const prepare = (result) => {
+		if (result.type === "graphql") {
+			const errorMaps = createErrorMaps(result.body.errors, projectionPathGraph);
+			return {
+				...result,
+				errorMaps
+			};
+		}
+		if (result.type === "non-graphql-error") return {
+			...result,
+			error: new SlicedExecutionResultError({
+				type: "non-graphql-error",
+				error: result.error
+			})
+		};
+		if (result.type === "empty") return {
+			...result,
+			error: new SlicedExecutionResultEmpty()
+		};
+		throw new Error("Invalid result type", { cause: result });
+	};
+	return (result) => {
+		const prepared = prepare(result);
+		const entries = Object.entries(fragments).map(([label, fragment]) => {
+			const { projection } = fragment;
+			if (prepared.type === "graphql") {
+				const matchedErrors = projection.paths.flatMap(({ full: raw }) => prepared.errorMaps[label]?.[raw] ?? []);
+				const uniqueErrors = Array.from(new Set(matchedErrors.map(({ error }) => error)).values());
+				if (uniqueErrors.length > 0) return [label, projection.projector(new SlicedExecutionResultError({
+					type: "graphql-error",
+					errors: uniqueErrors
+				}))];
+				const dataResults = projection.paths.map(({ segments }) => prepared.body.data ? accessDataByPathSegments(prepared.body.data, segments) : { error: /* @__PURE__ */ new Error("No data") });
+				if (dataResults.some(({ error }) => error)) {
+					const errors = dataResults.flatMap(({ error }) => error ? [error] : []);
+					return [label, projection.projector(new SlicedExecutionResultError({
+						type: "parse-error",
+						errors
+					}))];
+				}
+				const dataList = dataResults.map(({ data }) => data);
+				return [label, projection.projector(new SlicedExecutionResultSuccess(dataList))];
+			}
+			if (prepared.type === "non-graphql-error") return [label, projection.projector(prepared.error)];
+			if (prepared.type === "empty") return [label, projection.projector(prepared.error)];
+			throw new Error("Invalid result type", { cause: prepared });
+		});
+		return Object.fromEntries(entries);
+	};
+};
+
+//#endregion
+//#region packages/core/src/runtime/runtime-registry.ts
+const composedOperationRegistry = /* @__PURE__ */ new Map();
+const inlineOperationRegistry = /* @__PURE__ */ new Map();
+const registerComposedOperation = (operation) => {
+	composedOperationRegistry.set(operation.operationName, operation);
+};
+const registerInlineOperation = (operation) => {
+	inlineOperationRegistry.set(operation.operationName, operation);
+};
+const getComposedOperation = (name) => {
+	const operation = composedOperationRegistry.get(name);
+	if (!operation) throw new Error(`Operation ${name} not found`);
+	return operation;
+};
+const getInlineOperation = (name) => {
+	const operation = inlineOperationRegistry.get(name);
+	if (!operation) throw new Error(`Operation ${name} not found`);
+	return operation;
+};
+
+//#endregion
+//#region packages/core/src/runtime/composed-operation.ts
+const createRuntimeComposedOperation = (input) => {
+	const operation = {
+		operationType: input.prebuild.operationType,
+		operationName: input.prebuild.operationName,
+		variableNames: input.prebuild.variableNames,
+		projectionPathGraph: input.prebuild.projectionPathGraph,
+		document: input.prebuild.document,
+		parse: createExecutionResultParser({
+			fragments: input.runtime.getSlices({ $: createVarRefs(Object.fromEntries(input.prebuild.variableNames.map((name) => [name, null]))) }),
+			projectionPathGraph: input.prebuild.projectionPathGraph
+		})
+	};
+	registerComposedOperation(operation);
+	return operation;
+};
+
+//#endregion
+//#region packages/core/src/utils/hidden.ts
+const _dummy = () => {
+	throw new Error("DO NOT CALL THIS FUNCTION -- we use function to safely transfer type information");
+};
+const hidden = () => _dummy;
+
+//#endregion
+//#region packages/core/src/runtime/inline-operation.ts
+const createRuntimeInlineOperation = (input) => {
+	const operation = {
+		operationType: input.prebuild.operationType,
+		operationName: input.prebuild.operationName,
+		variableNames: input.prebuild.variableNames,
+		documentSource: hidden(),
+		document: input.prebuild.document
+	};
+	registerInlineOperation(operation);
+	return operation;
+};
+
+//#endregion
+//#region packages/core/src/runtime/model.ts
+const createRuntimeModel = (input) => ({
+	typename: input.prebuild.typename,
+	fragment: hidden(),
+	normalize: input.runtime.normalize
+});
+
+//#endregion
+//#region packages/core/src/runtime/slice.ts
+const handleProjectionBuilder = (projectionBuilder) => projectionBuilder({ select: (path, projector) => new Projection(path, projector) });
+const createRuntimeSlice = (input) => {
+	const projection = handleProjectionBuilder(input.runtime.buildProjection);
+	return {
+		operationType: input.prebuild.operationType,
+		embed: (variables) => ({
+			variables,
+			getFields: hidden(),
+			projection
+		})
+	};
+};
+
+//#endregion
+//#region packages/core/src/runtime/runtime-adapter.ts
+const createRuntimeAdapter = (factory) => factory({ type: hidden });
+
+//#endregion
+//#region packages/core/src/runtime/index.ts
+const gqlRuntime = {
+	model: createRuntimeModel,
+	composedOperation: createRuntimeComposedOperation,
+	inlineOperation: createRuntimeInlineOperation,
+	slice: createRuntimeSlice,
+	getComposedOperation,
+	getInlineOperation
+};
+
+//#endregion
+exports.createRuntimeAdapter = createRuntimeAdapter;
+exports.gqlRuntime = gqlRuntime;