@mearie/core 0.0.0 → 0.0.1-next.3

package/dist/index.js

@@ -1,5 +1,682 @@
+import { configureSync, getAnsiColorFormatter, getConsoleSink, getLogger } from "@logtape/logtape";
+import pc from "picocolors";
+
+//#region src/errors.ts
+/**
+* Custom error class for Mearie-specific errors.
+*/
+var MearieError = class MearieError extends Error {
+	filePath;
+	line;
+	column;
+	constructor(message, filePath, line, column) {
+		super(message);
+		this.name = "MearieError";
+		this.filePath = filePath;
+		this.line = line;
+		this.column = column;
+	}
+	static fromNative(data) {
+		if (!data || typeof data !== "object") throw new TypeError("Invalid native error data");
+		const error = data;
+		const filePath = error.location?.file_path;
+		const line = error.location?.line;
+		const column = error.location?.column;
+		return new MearieError(error.message, filePath, line, column);
+	}
+};
+/**
+* Aggregate error for multiple Mearie errors.
+*/
+var MearieAggregateError = class extends Error {
+	errors;
+	constructor(errors, message) {
+		super(message ?? `${errors.length} error${errors.length > 1 ? "s" : ""} occurred`);
+		this.name = "MearieAggregateError";
+		this.errors = errors;
+	}
+};
+
+//#endregion
+//#region src/utils.ts
+/**
+* Stable JSON serialization with sorted keys.
+* Used for both variables and field arguments.
+* @internal
+* @param value - The value to stringify.
+* @returns The stable JSON string.
+*/
+const stableStringify = (value) => {
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	const type = typeof value;
+	if (type === "string") return JSON.stringify(value);
+	if (type === "number" || type === "boolean") return String(value);
+	if (Array.isArray(value)) return "[" + value.map((v) => stableStringify(v)).join(",") + "]";
+	if (type === "object") {
+		const obj = value;
+		return "{" + Object.keys(obj).toSorted().map((k) => `"${k}":${stableStringify(obj[k])}`).join(",") + "}";
+	}
+	return JSON.stringify(value) ?? "";
+};
+/**
+* Hash a string using FNV-1a algorithm.
+* @internal
+* @param str - The string to hash.
+* @returns The hash value.
+*/
+const hashString = (str) => {
+	const FNV_OFFSET = 2166136261;
+	const FNV_PRIME = 16777619;
+	let hash = FNV_OFFSET;
+	for (let i = 0; i < str.length; i++) {
+		hash ^= str.codePointAt(i) ?? 0;
+		hash = Math.imul(hash, FNV_PRIME);
+	}
+	return hash >>> 0;
+};
+/**
+* Combine two hashes using FNV-1a algorithm.
+* Used for query key generation.
+* @internal
+* @param hash1 - The first hash.
+* @param hash2 - The second hash.
+* @returns The combined hash.
+*/
+const combineHashes = (hash1, hash2) => {
+	const FNV_PRIME = 16777619;
+	let hash = hash1;
+	for (let i = 0; i < 4; i++) {
+		hash ^= hash2 >> i * 8 & 255;
+		hash = Math.imul(hash, FNV_PRIME);
+	}
+	return hash >>> 0;
+};
+
+//#endregion
+//#region src/logger.ts
+configureSync({
+	sinks: { console: getConsoleSink({ formatter: getAnsiColorFormatter({
+		level: "FULL",
+		timestamp: "time",
+		category: (category) => `💬 ${category.join("·")}`
+	}) }) },
+	loggers: [{
+		category: "mearie",
+		lowestLevel: "info",
+		sinks: ["console"]
+	}, {
+		category: ["logtape", "meta"],
+		lowestLevel: "warning",
+		sinks: ["console"]
+	}]
+});
+const logger = getLogger(["mearie"]);
+const formatMearieError = (error) => {
+	const parts = [
+		error.filePath,
+		error.line,
+		error.column
+	].filter((part) => part !== void 0 && part !== null).map(String);
+	const location = parts.length > 0 ? parts.join(":") : "";
+	if (location) return `${pc.bold(error.message)} ${pc.cyan(pc.underline(location))}`;
+	return pc.bold(error.message);
+};
+/**
+* Reports an error using the provided logger.
+* @param logger - The logger to use.
+* @param error - The error to report.
+*/
+const report = (logger$1, error) => {
+	if (error instanceof MearieAggregateError) for (const err of error.errors) logger$1.error(formatMearieError(err));
+	else if (error instanceof MearieError) logger$1.error(formatMearieError(error));
+	else logger$1.error("{error}", { error });
+};
+
+//#endregion
+//#region src/link.ts
+/**
+* @param links - The chain of links to execute.
+* @param ctx - The link context.
+* @param finalHandler - The final handler function.
+* @returns The link result.
+*/
+const executeLinks = (links, ctx, finalHandler) => {
+	let index = 0;
+	const dispatch = async () => {
+		if (index >= links.length) return await finalHandler(ctx);
+		const link = links[index++];
+		if (!link) throw new Error("Link is undefined");
+		return link.execute(ctx, dispatch);
+	};
+	return dispatch();
+};
+
+//#endregion
+//#region src/links/dedup.ts
+/**
+* @returns The deduplication link.
+*/
+const createDedupLink = () => {
+	const pending = /* @__PURE__ */ new Map();
+	return {
+		name: "dedup",
+		async execute(ctx, next) {
+			const { document, variables } = ctx.operation;
+			const queryHash = document.hash;
+			const key = combineHashes(queryHash, variables ? hashString(stableStringify(variables)) : 0);
+			const existing = pending.get(key);
+			if (existing) return existing;
+			const promise = next();
+			pending.set(key, promise);
+			try {
+				return await promise;
+			} finally {
+				pending.delete(key);
+			}
+		}
+	};
+};
+const dedupLink = createDedupLink;
+
+//#endregion
+//#region src/links/retry.ts
+/**
+* @param options - The retry options.
+* @returns The retry link.
+*/
+const createRetryLink = (options = {}) => {
+	const { maxAttempts = 3, backoff = (attempt) => Math.min(1e3 * 2 ** attempt, 3e4), shouldRetry = () => true } = options;
+	return {
+		name: "retry",
+		async execute(ctx, next) {
+			let lastError;
+			for (let attempt = 0; attempt < maxAttempts; attempt++) try {
+				return await next();
+			} catch (error) {
+				lastError = error;
+				if (attempt === maxAttempts - 1 || !shouldRetry(error)) throw error;
+				const delay = backoff(attempt);
+				await new Promise((resolve) => setTimeout(resolve, delay));
+			}
+			throw lastError;
+		}
+	};
+};
+const retryLink = createRetryLink;
+
+//#endregion
+//#region src/links/fetch.ts
+/**
+* @param options - The HTTP options.
+* @returns The HTTP link.
+*/
+const createHttpLink = (options) => {
+	const { url, credentials = "same-origin", headers = {} } = options;
+	return {
+		name: "http",
+		async execute(ctx) {
+			const { document, variables, headers: operationHeaders } = ctx.operation;
+			const response = await fetch(url, {
+				method: "POST",
+				credentials,
+				headers: {
+					"Content-Type": "application/json",
+					...headers,
+					...operationHeaders
+				},
+				body: JSON.stringify({
+					query: document.body,
+					variables
+				}),
+				signal: ctx.signal
+			});
+			if (!response.ok) throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+			return response.json();
+		}
+	};
+};
+const httpLink = createHttpLink;
+
+//#endregion
+//#region src/links/auth.ts
+/**
+* @param options - The authentication options.
+* @returns The authentication link.
+*/
+const createAuthLink = (options) => {
+	const { getToken, refreshToken, header = "Authorization" } = options;
+	return {
+		name: "auth",
+		async execute(ctx, next) {
+			const token = await getToken();
+			if (token) ctx.operation.headers = {
+				...ctx.operation.headers,
+				[header]: `Bearer ${token}`
+			};
+			try {
+				return await next();
+			} catch (error) {
+				if (refreshToken && typeof error === "object" && error !== null && "response" in error && typeof error.response === "object" && error.response !== null && "status" in error.response && error.response.status === 401) {
+					const newToken = await refreshToken();
+					ctx.operation.headers = {
+						...ctx.operation.headers,
+						[header]: `Bearer ${newToken}`
+					};
+					return next();
+				}
+				throw error;
+			}
+		}
+	};
+};
+const authLink = createAuthLink;
+
+//#endregion
+//#region src/links/cache.ts
+/**
+* @param options - The cache options.
+* @returns The cache link.
+*/
+const createCacheLink = (options) => {
+	const { cache, fetchPolicy = "cache-first" } = options;
+	return {
+		name: "cache",
+		async execute(ctx, next) {
+			const { document, variables, kind } = ctx.operation;
+			if (kind === "mutation" || kind === "subscription") {
+				const result$1 = await next();
+				if (kind === "mutation" && result$1.data) cache.writeQuery(document, variables, result$1.data);
+				return result$1;
+			}
+			if (fetchPolicy === "network-only") {
+				const result$1 = await next();
+				if (result$1.data) cache.writeQuery(document, variables, result$1.data);
+				return result$1;
+			}
+			const cached = cache.readQuery(document, variables);
+			if (fetchPolicy === "cache-only") return { data: cached ?? void 0 };
+			if (fetchPolicy === "cache-first" && cached) return { data: cached };
+			const result = await next();
+			if (result.data) cache.writeQuery(document, variables, result.data);
+			return result;
+		}
+	};
+};
+const cacheLink = createCacheLink;
+
+//#endregion
+//#region src/cache/constants.ts
+/**
+* Special key used to mark normalized entity references in the cache.
+* When an entity is normalized, it's replaced with an object containing this key
+* with the entity key as the value.
+* @internal
+*/
+const EntityLinkKey = "__ref";
+/**
+* Special key for storing root query fields.
+* @internal
+*/
+const RootFieldKey = "__root";
+
+//#endregion
+//#region src/cache/utils.ts
+/**
+* Generates a unique cache key for an entity based on its typename and key field values.
+* @internal
+* @param typename - The GraphQL typename of the entity.
+* @param keyValues - Array of key field values used to identify the entity.
+* @returns A unique entity key in the format "typename:value1:value2:...".
+*/
+const makeEntityKey = (typename, keyValues) => {
+	return `${typename}:${keyValues.join(":")}`;
+};
+/**
+* Resolves GraphQL arguments by replacing variable references with their actual values.
+* @internal
+* @param args - Argument definitions from the query, containing either literal values or variable references.
+* @param variables - Object containing the actual variable values.
+* @returns Object with all arguments resolved to their actual values.
+*/
+const resolveArguments = (args, variables) => {
+	const resolved = {};
+	for (const [key, value] of Object.entries(args)) resolved[key] = value.kind === "literal" ? value.value : variables[value.name];
+	return resolved;
+};
+/**
+* Generates a cache key for a GraphQL field selection.
+* Always uses the actual field name (not alias) with a hash of the arguments.
+* @internal
+* @param selection - The selection node containing field information.
+* @param variables - Variable values for resolving argument references.
+* @returns Field cache key string in "fieldName@argsHash" format.
+*/
+const makeFieldKey = (selection, variables) => {
+	const argsHash = hashString(stableStringify(selection.args ? resolveArguments(selection.args, variables) : {}));
+	return `${selection.name}@${argsHash}`;
+};
+/**
+* Retrieves entity metadata from the schema for a given typename.
+* @internal
+* @param typename - The GraphQL typename to look up.
+* @param schemaMetadata - The schema metadata containing entity configurations.
+* @returns Entity metadata if found, undefined otherwise.
+*/
+const getEntityMetadata = (typename, schemaMetadata) => {
+	return typename ? schemaMetadata.entities[typename] : void 0;
+};
+/**
+* Creates a unique query key combining document hash and variables.
+* @internal
+* @param hash - Document hash.
+* @param variables - Query variables.
+* @returns Unique query key.
+*/
+const makeQueryKey = (hash, variables) => {
+	if (!variables || typeof variables === "object" && Object.keys(variables).length === 0) return hash;
+	return combineHashes(hash, hashString(stableStringify(variables)));
+};
+/**
+* Gets a unique key for tracking a field dependency.
+* @internal
+* @param storageKey Storage key (entity or root query key).
+* @param fieldKey Field key.
+* @returns Unique dependency key in the format "storageKey.field".
+*/
+const makeDependencyKey = (storageKey, fieldKey) => {
+	return `${storageKey}.${fieldKey}`;
+};
+/**
+* Type guard to check if a value is an entity link.
+* @internal
+* @param value - Value to check.
+* @returns True if the value is an EntityLink.
+*/
+const isEntityLink = (value) => {
+	return typeof value === "object" && value !== null && EntityLinkKey in value;
+};
+
+//#endregion
+//#region src/cache/normalize.ts
+/**
+* @param data - The data to normalize.
+* @param selections - The selection nodes.
+* @param schemaMetadata - The schema metadata.
+* @param storage - The normalized storage map.
+* @param variables - The variable values.
+* @param accessor - Callback invoked when a field dependency is encountered.
+*/
+const normalize = (data, selections, schemaMetadata, storage, variables, accessor) => {
+	const normalizeField = (parentKey, selections$1, value) => {
+		if (value === null || value === void 0) return value;
+		if (typeof value !== "object" || Array.isArray(value)) return value;
+		const data$1 = value;
+		const fields = {};
+		for (const selection of selections$1) {
+			const fieldKey = makeFieldKey(selection, variables);
+			const fieldValue = data$1[selection.alias ?? selection.name];
+			accessor(parentKey, fieldKey);
+			if (fieldValue === void 0) continue;
+			if (Array.isArray(fieldValue)) fields[fieldKey] = fieldValue.map((item) => selection.selections ? normalizeField(parentKey, selection.selections, item) : item);
+			else if (selection.selections) fields[fieldKey] = normalizeField(parentKey, selection.selections, fieldValue);
+			else fields[fieldKey] = fieldValue;
+		}
+		const typename = data$1.__typename;
+		const entityMetadata = typename ? getEntityMetadata(typename, schemaMetadata) : void 0;
+		if (entityMetadata) {
+			const keyValues = [];
+			for (const field of entityMetadata.keyFields) {
+				const fieldValue = data$1[field];
+				if (fieldValue == null) return fields;
+				keyValues.push(fieldValue);
+			}
+			const entityKey = makeEntityKey(typename, keyValues);
+			const normalized = {
+				...storage.get(entityKey) ?? {},
+				...fields
+			};
+			storage.set(entityKey, normalized);
+			return { [EntityLinkKey]: entityKey };
+		}
+		return fields;
+	};
+	if (data === null || typeof data !== "object") return;
+	const existingRoot = storage.get(RootFieldKey) ?? {};
+	const result = normalizeField(RootFieldKey, selections, data);
+	storage.set(RootFieldKey, {
+		...existingRoot,
+		...result
+	});
+};
+
+//#endregion
+//#region src/cache/denormalize.ts
+/**
+* @param value - The value to denormalize.
+* @param selection - The selection node.
+* @param storage - The normalized storage map.
+* @param variables - The variable values.
+* @param sourceData - The source data object.
+* @returns The denormalized value.
+*/
+const denormalizeValue = (value, selection, storage, variables, sourceData) => {
+	if (value === null || value === void 0) return value;
+	if (selection.array && Array.isArray(value)) return value.map((item) => denormalizeValue(item, selection, storage, variables, sourceData));
+	if (typeof value !== "object" || Array.isArray(value)) return value;
+	const data = value;
+	let source = sourceData ?? data;
+	if (isEntityLink(data)) {
+		const entity = storage.get(data[EntityLinkKey]);
+		if (!entity || !selection.selections) return value;
+		source = entity;
+		sourceData = entity;
+	}
+	if (!selection.selections) return value;
+	const result = {};
+	for (const childSelection of selection.selections) {
+		const fieldKey = sourceData ? makeFieldKey(childSelection, variables) : childSelection.alias ?? childSelection.name;
+		const responseKey = childSelection.alias ?? childSelection.name;
+		const fieldValue = source[fieldKey];
+		if (fieldValue !== void 0) result[responseKey] = denormalizeValue(fieldValue, childSelection, storage, variables, sourceData);
+	}
+	return result;
+};
+/**
+* @param selections - The selection nodes.
+* @param storage - The normalized storage map.
+* @param variables - The variable values.
+* @returns The denormalized data.
+*/
+const denormalize = (selections, storage, variables) => {
+	const queryRoot = storage.get(RootFieldKey);
+	if (!queryRoot) return null;
+	const result = {};
+	for (const selection of selections) {
+		const fieldKey = makeFieldKey(selection, variables);
+		const responseKey = selection.alias ?? selection.name;
+		const fieldValue = queryRoot[fieldKey];
+		if (fieldValue !== void 0) result[responseKey] = denormalizeValue(fieldValue, selection, storage, variables, queryRoot);
+	}
+	return Object.keys(result).length === 0 ? null : result;
+};
+
+//#endregion
+//#region src/cache/cache.ts
+/**
+* A normalized cache that stores and manages GraphQL query results and entities.
+* Supports entity normalization, cache invalidation, and reactive updates through subscriptions.
+*/
+var Cache = class {
+	#storage = /* @__PURE__ */ new Map();
+	#dependencies = /* @__PURE__ */ new Map();
+	#listeners = /* @__PURE__ */ new Map();
+	#schemaMetadata;
+	constructor(schemaMetadata) {
+		this.#schemaMetadata = schemaMetadata;
+	}
+	/**
+	* Writes a query result to the cache, normalizing entities and tracking dependencies.
+	* @param document - GraphQL document node.
+	* @param variables - Query variables.
+	* @param result - Query result data.
+	*/
+	writeQuery(document, variables, result) {
+		const queryKey = makeQueryKey(document.hash, variables);
+		normalize(result, document.selections, this.#schemaMetadata, this.#storage, variables, (storageKey, fieldKey) => {
+			this.#trackDependency(queryKey, storageKey, fieldKey);
+		});
+		this.#notifyListeners(queryKey);
+	}
+	/**
+	* Reads a query result from the cache, denormalizing entities if available.
+	* @param document - GraphQL document node.
+	* @param variables - Query variables.
+	* @returns Denormalized query result or null if not found.
+	*/
+	readQuery(document, variables) {
+		return denormalize(document.selections, this.#storage, variables);
+	}
+	/**
+	* Subscribes to cache invalidations for a specific query.
+	* @param document - GraphQL document node.
+	* @param variables - Query variables.
+	* @param callback - Callback function to invoke on cache invalidation.
+	* @returns Unsubscribe function.
+	*/
+	subscribe(document, variables, callback) {
+		const queryKey = makeQueryKey(document.hash, variables);
+		let listeners = this.#listeners.get(queryKey);
+		if (!listeners) {
+			listeners = /* @__PURE__ */ new Set();
+			this.#listeners.set(queryKey, listeners);
+		}
+		listeners.add(callback);
+		return () => {
+			listeners.delete(callback);
+			if (listeners.size === 0) this.#listeners.delete(queryKey);
+		};
+	}
+	/**
+	* Evicts a query from the cache and notifies listeners.
+	* @param document - GraphQL document node.
+	* @param variables - Query variables.
+	*/
+	evictQuery(document, variables) {
+		const queryKey = makeQueryKey(document.hash, variables);
+		const queryRoot = this.#storage.get(RootFieldKey);
+		if (queryRoot) for (const selection of document.selections) {
+			const fieldKey = makeFieldKey(selection, variables);
+			delete queryRoot[fieldKey];
+		}
+		this.#notifyListeners(queryKey);
+	}
+	/**
+	* Clears all cache data.
+	*/
+	clear() {
+		this.#storage.clear();
+		this.#dependencies.clear();
+		this.#listeners.clear();
+	}
+	/**
+	* Tracks dependency between a query and a storage field.
+	* @param queryKey - Query key to track.
+	* @param storageKey - Storage key (entity or root).
+	* @param fieldKey - Field key.
+	*/
+	#trackDependency(queryKey, storageKey, fieldKey) {
+		const dependencyKey = makeDependencyKey(storageKey, fieldKey);
+		let queryKeys = this.#dependencies.get(dependencyKey);
+		if (!queryKeys) {
+			queryKeys = /* @__PURE__ */ new Set();
+			this.#dependencies.set(dependencyKey, queryKeys);
+		}
+		queryKeys.add(queryKey);
+	}
+	/**
+	* Notifies all listeners subscribed to a query.
+	* @param queryKey - Query key to notify listeners for.
+	*/
+	#notifyListeners(queryKey) {
+		const listeners = this.#listeners.get(queryKey);
+		if (listeners) for (const listener of listeners) listener();
+	}
+};
+
+//#endregion
+//#region src/client.ts
+/**
+* GraphQL client for executing queries and mutations.
+*/
+var Client = class {
+	links;
+	cache;
+	/**
+	* @param config - The client configuration.
+	*/
+	constructor(config) {
+		this.links = config.links.map((link) => typeof link === "function" ? link() : link);
+		this.cache = config.cache;
+	}
+	/**
+	* @param document - The query document.
+	* @param variables - The query variables.
+	* @returns The query result.
+	*/
+	async query(document, variables) {
+		return { data: {} };
+	}
+	/**
+	* @param document - The mutation document.
+	* @param variables - The mutation variables.
+	* @returns The mutation result.
+	*/
+	async mutate(document, variables) {
+		return { data: {} };
+	}
+	/**
+	* @param document - The mutation document.
+	* @param variables - The mutation variables.
+	* @returns The mutation result.
+	*/
+	async mutation(document, variables) {
+		return { data: {} };
+	}
+	/**
+	* @param document - The subscription document.
+	* @param variables - The subscription variables.
+	* @returns An observable of subscription results.
+	*/
+	subscription(document, variables) {
+		return { subscribe: () => ({ unsubscribe: () => {} }) };
+	}
+	/**
+	* @param fragment - The fragment document.
+	* @param fragmentRef - The fragment reference data.
+	* @returns The fragment data.
+	*/
+	readFragment(fragment, fragmentRef) {
+		return {};
+	}
+	/**
+	* @returns The normalized cache instance.
+	*/
+	getCache() {
+		return this.cache;
+	}
+};
+/**
+* @param config - The client configuration.
+* @returns A new client instance.
+*/
+const createClient = (config) => {
+	return new Client(config);
+};
+
+//#endregion
 //#region src/index.ts
-var src_default = {};
+const graphql = () => {};
 
 //#endregion
-export { src_default as default };
+export { Client, MearieAggregateError, MearieError, Cache as NormalizedCache, authLink, cacheLink, combineHashes, createClient, dedupLink, executeLinks, graphql, hashString, httpLink, logger, report, retryLink, stableStringify };