@soda-gql/runtime 0.1.0 → 0.3.0

package/README.md

@@ -16,7 +16,7 @@ bun add @soda-gql/runtime
 This package provides the minimal runtime needed to execute soda-gql GraphQL operations. It includes:
 
 - Operation registry for storing compiled GraphQL documents
-- Runtime adapter for operation retrieval
+- Runtime utilities for operation retrieval
 - Minimal footprint for production builds
 
 ## Usage
@@ -30,29 +30,17 @@ When using soda-gql with a build plugin (Babel, TypeScript, Vite, etc.), the run
 import { gql } from "@/graphql-system";
 
 export const userQuery = gql.default(({ query }, { $var }) =>
-  query.composed(
-    { operationName: "GetUser", variables: [$var("id").scalar("ID:!")] },
-    ({ $ }) => ({ user: userSlice.build({ id: $.id }) }),
-  ),
+  query.operation({
+    name: "GetUser",
+    variables: { ...$var("id").ID("!") },
+    fields: ({ f, $ }) => ({ ...f.user({ id: $.id })(({ f }) => ({ ...f.id(), ...f.name() })) }),
+  }),
 );
 
 // After transformation (automatically handled by build plugin)
 import { gqlRuntime } from "@soda-gql/runtime";
 
-export const userQuery = gqlRuntime.getComposedOperation("canonicalId");
-```
-
-### Runtime Adapter
-
-For custom client integrations, create a runtime adapter that defines error types:
-
-```typescript
-import { createRuntimeAdapter } from "@soda-gql/runtime";
-
-export const adapter = createRuntimeAdapter(({ type }) => ({
-  // Define the shape of non-GraphQL errors (network errors, etc.)
-  nonGraphqlErrorType: type<{ type: "non-graphql-error"; cause: unknown }>(),
-}));
+export const userQuery = gqlRuntime.getOperation("canonicalId");
 ```
 
 ## API Reference
@@ -64,32 +52,8 @@ The main runtime object for operation management:
 ```typescript
 import { gqlRuntime } from "@soda-gql/runtime";
 
-// Get a composed operation by canonical ID
-const operation = gqlRuntime.getComposedOperation("path/to/file.ts::userQuery");
-
-// Get an inline operation
-const inlineOp = gqlRuntime.getInlineOperation("canonicalId");
-
-// Get a model
-const model = gqlRuntime.getModel("canonicalId");
-
-// Get a slice
-const slice = gqlRuntime.getSlice("canonicalId");
-```
-
-### `createRuntimeAdapter(options)`
-
-Create a custom runtime adapter for client integration:
-
-```typescript
-import { createRuntimeAdapter } from "@soda-gql/runtime";
-
-const adapter = createRuntimeAdapter({
-  errorTypes: {
-    network: (message, cause) => new NetworkError(message, cause),
-    unknown: (message, cause) => new UnknownError(message, cause),
-  },
-});
+// Get an operation by canonical ID
+const operation = gqlRuntime.getOperation("path/to/file.ts::userQuery");
 ```
 
 ## Zero-Runtime Philosophy

package/dist/index.cjs

@@ -1,317 +1,8 @@
-
-//#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 createVarRefFromVariable = (name) => {
-	return new VarRef({
-		type: "variable",
-		name
-	});
-};
-
-//#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 createVarRefs = (definitions) => mapValues(definitions, (_ref, name) => createVarRefFromVariable(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
-		}),
-		metadata: input.prebuild.metadata
-	};
-	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,
-		metadata: input.prebuild.metadata
-	};
-	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;
+let __soda_gql_core_runtime = require("@soda-gql/core/runtime");
+
+Object.defineProperty(exports, 'gqlRuntime', {
+  enumerable: true,
+  get: function () {
+    return __soda_gql_core_runtime.gqlRuntime;
+  }
+});