@soda-gql/core 0.1.0 → 0.3.0

package/dist/slice-C-FIQK-f.cjs

@@ -1,373 +0,0 @@
-
-//#region packages/core/src/types/type-foundation/var-ref.ts
-var VarRef = class {
-	constructor(inner) {
-		this.inner = inner;
-	}
-	static getInner(varRef) {
-		return varRef.inner;
-	}
-};
-const isVarRef = (value) => {
-	return typeof value === "object" && value !== null && value instanceof VarRef;
-};
-const createVarRefFromVariable = (name) => {
-	return new VarRef({
-		type: "variable",
-		name
-	});
-};
-const createVarRefFromConstValue = (value) => {
-	return new VarRef({
-		type: "const-value",
-		value
-	});
-};
-const getVarRefInner = (varRef) => {
-	return VarRef.getInner(varRef);
-};
-/**
-* Get the variable name from a VarRef.
-* Throws if the VarRef contains a const-value instead of a variable reference.
-*/
-const getVarRefName = (varRef) => {
-	const inner = VarRef.getInner(varRef);
-	if (inner.type !== "variable") throw new Error("Expected variable reference, got const-value");
-	return inner.name;
-};
-/**
-* Get the const value from a VarRef.
-* Throws if the VarRef contains a variable reference instead of a const-value.
-*/
-const getVarRefValue = (varRef) => {
-	const inner = VarRef.getInner(varRef);
-	if (inner.type !== "const-value") throw new Error("Expected const-value, got variable reference");
-	return inner.value;
-};
-
-//#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/utils/map-values.ts
-function mapValues(obj, fn) {
-	return Object.fromEntries(Object.entries(obj).map(([key, value]) => [key, fn(value, key)]));
-}
-
-//#endregion
-//#region packages/core/src/composer/input.ts
-const mergeVarDefinitions = (definitions) => Object.assign({}, ...definitions);
-const createVarAssignments = (definitions, providedValues) => {
-	return mapValues(definitions, (_definition, key) => {
-		const varName = key;
-		if (!providedValues || providedValues[varName] === void 0) return createVarRefFromConstValue(void 0);
-		const provided = providedValues[varName];
-		if (isVarRef(provided)) return provided;
-		return createVarRefFromConstValue(provided);
-	});
-};
-const createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => createVarRefFromVariable(name));
-
-//#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/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
-Object.defineProperty(exports, 'Projection', {
-  enumerable: true,
-  get: function () {
-    return Projection;
-  }
-});
-Object.defineProperty(exports, 'SlicedExecutionResultEmpty', {
-  enumerable: true,
-  get: function () {
-    return SlicedExecutionResultEmpty;
-  }
-});
-Object.defineProperty(exports, 'SlicedExecutionResultError', {
-  enumerable: true,
-  get: function () {
-    return SlicedExecutionResultError;
-  }
-});
-Object.defineProperty(exports, 'SlicedExecutionResultSuccess', {
-  enumerable: true,
-  get: function () {
-    return SlicedExecutionResultSuccess;
-  }
-});
-Object.defineProperty(exports, 'VarRef', {
-  enumerable: true,
-  get: function () {
-    return VarRef;
-  }
-});
-Object.defineProperty(exports, 'createExecutionResultParser', {
-  enumerable: true,
-  get: function () {
-    return createExecutionResultParser;
-  }
-});
-Object.defineProperty(exports, 'createRuntimeSlice', {
-  enumerable: true,
-  get: function () {
-    return createRuntimeSlice;
-  }
-});
-Object.defineProperty(exports, 'createVarAssignments', {
-  enumerable: true,
-  get: function () {
-    return createVarAssignments;
-  }
-});
-Object.defineProperty(exports, 'createVarRefs', {
-  enumerable: true,
-  get: function () {
-    return createVarRefs;
-  }
-});
-Object.defineProperty(exports, 'getVarRefInner', {
-  enumerable: true,
-  get: function () {
-    return getVarRefInner;
-  }
-});
-Object.defineProperty(exports, 'getVarRefName', {
-  enumerable: true,
-  get: function () {
-    return getVarRefName;
-  }
-});
-Object.defineProperty(exports, 'getVarRefValue', {
-  enumerable: true,
-  get: function () {
-    return getVarRefValue;
-  }
-});
-Object.defineProperty(exports, 'handleProjectionBuilder', {
-  enumerable: true,
-  get: function () {
-    return handleProjectionBuilder;
-  }
-});
-Object.defineProperty(exports, 'hidden', {
-  enumerable: true,
-  get: function () {
-    return hidden;
-  }
-});
-Object.defineProperty(exports, 'mapValues', {
-  enumerable: true,
-  get: function () {
-    return mapValues;
-  }
-});
-Object.defineProperty(exports, 'mergeVarDefinitions', {
-  enumerable: true,
-  get: function () {
-    return mergeVarDefinitions;
-  }
-});