@nkzw/fate 0.1.3 → 1.0.0

package/lib/list-4wRNSVgI.d.mts

@@ -0,0 +1,10 @@
+import { U as List, o as EntityId } from "./types-Dz46PXr3.mjs";
+
+//#region src/list.d.ts
+type ListEntry = Readonly<{
+  cursor?: string;
+  id: EntityId;
+}>;
+declare const getListEntries: (listState: List | undefined) => Array<ListEntry>;
+//#endregion
+export { getListEntries as n, ListEntry as t };

package/lib/list-C_mi6GnE.mjs

@@ -0,0 +1,16 @@
+//#region src/list.ts
+const getListEntries = (listState) => {
+	if (!listState) return [];
+	const entries = [];
+	for (const id of listState.pendingBeforeIds ?? []) entries.push({ id });
+	listState.ids.forEach((id, index) => {
+		entries.push({
+			cursor: listState.cursors?.[index],
+			id
+		});
+	});
+	for (const id of listState.pendingAfterIds ?? []) entries.push({ id });
+	return entries;
+};
+//#endregion
+export { getListEntries as t };

package/lib/list.d.mts

@@ -0,0 +1,2 @@
+import { n as getListEntries, t as ListEntry } from "./list-4wRNSVgI.mjs";
+export { ListEntry, getListEntries };

package/lib/list.mjs

@@ -0,0 +1,2 @@
+import { t as getListEntries } from "./list-C_mi6GnE.mjs";
+export { getListEntries };

package/lib/liveTopics-DzNtJaBD.mjs

@@ -0,0 +1,197 @@
+import { t as isRecord } from "./record-AeZJC9fd.mjs";
+//#region src/args.ts
+const ensureSerializable = (value, path) => {
+	const type = typeof value;
+	if (type === "function" || type === "symbol") throw new Error(`fate: Argument '${path}' must be serializable. Received '${type}'.`);
+};
+const cloneArgs = (value, path) => {
+	const cloneValue = (entry, currentPath) => {
+		if (Array.isArray(entry)) return entry.map((item, index) => cloneValue(item, `${currentPath}[${index}]`));
+		if (isRecord(entry)) {
+			const result = {};
+			for (const [key, child] of Object.entries(entry)) result[key] = cloneValue(child, `${currentPath}.${key}`);
+			return result;
+		}
+		ensureSerializable(entry, currentPath);
+		return entry;
+	};
+	return cloneValue(value, path);
+};
+const paginationArgKeys = new Set([
+	"after",
+	"before",
+	"cursor",
+	"first",
+	"last"
+]);
+const stableSerialize = (value) => {
+	if (value === null) return "null";
+	const type = typeof value;
+	if (type === "number" || type === "boolean" || type === "bigint") return `${type}:${String(value)}`;
+	if (type === "string") return `string:${JSON.stringify(value)}`;
+	if (type === "undefined") return "undefined";
+	if (Array.isArray(value)) return `array:[${value.map(stableSerialize).join(",")}]`;
+	if (typeof value === "object") return `object:{${Object.entries(value).map(([key, entry]) => [key, entry]).sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0).map(([_key, entry]) => `${JSON.stringify(_key)}:${stableSerialize(entry)}`).join(",")}}`;
+	throw new Error(`fate: Unable to serialize argument value of type '${type}'.`);
+};
+const hashArgs = (argsValue, options = {}) => {
+	const keys = {};
+	for (const [key, value] of Object.entries(argsValue)) {
+		if (options.ignoreKeys && options.ignoreKeys.has(key)) continue;
+		keys[key] = value;
+	}
+	return stableSerialize(keys);
+};
+const filterConnectionArgs = (argsValue) => {
+	if (!argsValue) return;
+	const result = {};
+	for (const [key, value] of Object.entries(argsValue)) if (!paginationArgKeys.has(key)) result[key] = value;
+	return Object.keys(result).length > 0 ? result : void 0;
+};
+const mergeArgs = (target, source) => {
+	for (const [key, value] of Object.entries(source)) {
+		if (isRecord(value)) {
+			const existing = target[key];
+			if (isRecord(existing)) mergeArgs(existing, value);
+			else target[key] = { ...value };
+			continue;
+		}
+		target[key] = value;
+	}
+};
+const resolvedArgsFromPlan = (plan) => {
+	if (!plan || plan.args.size === 0) return;
+	const result = {};
+	for (const [path, entry] of plan.args.entries()) {
+		if (path === "") {
+			mergeArgs(result, entry.value);
+			continue;
+		}
+		const segments = path.split(".");
+		let current = result;
+		segments.forEach((segment, index) => {
+			if (index === segments.length - 1) {
+				const existing = current[segment];
+				if (isRecord(existing)) mergeArgs(existing, entry.value);
+				else current[segment] = { ...entry.value };
+				return;
+			}
+			const existing = current[segment];
+			if (isRecord(existing)) {
+				current = existing;
+				return;
+			}
+			const next = {};
+			current[segment] = next;
+			current = next;
+		});
+	}
+	return result;
+};
+const hasEntries = (value) => Boolean(value && Object.keys(value).length > 0);
+const combineArgsPayload = (base, scoped) => {
+	if (!hasEntries(base) && !hasEntries(scoped)) return;
+	const result = hasEntries(base) ? { ...base } : {};
+	if (hasEntries(scoped)) mergeArgs(result, scoped);
+	return result;
+};
+const getArgsAtPath = (payload, path) => {
+	if (!payload) return;
+	if (path === "") return payload;
+	const segments = path.split(".");
+	let current = payload;
+	for (const segment of segments) {
+		if (!isRecord(current)) return;
+		current = current[segment];
+		if (current === void 0) return;
+	}
+	return isRecord(current) ? current : void 0;
+};
+const applyArgsPayloadToPlan = (plan, payload) => {
+	for (const [path, entry] of plan.args.entries()) {
+		const actual = path === "" ? payload : getArgsAtPath(payload, path);
+		if (!actual) continue;
+		const cloned = cloneArgs(actual, path);
+		const hash = hashArgs(cloned, { ignoreKeys: entry.ignoreKeys });
+		plan.args.set(path, {
+			hash,
+			ignoreKeys: entry.ignoreKeys,
+			value: cloned
+		});
+	}
+};
+const scopeArgsPayload = (args, scope) => {
+	const segments = scope.split(".");
+	const result = {};
+	let current = result;
+	segments.forEach((segment, index) => {
+		if (index === segments.length - 1) {
+			current[segment] = args;
+			return;
+		}
+		const next = {};
+		current[segment] = next;
+		current = next;
+	});
+	return result;
+};
+//#endregion
+//#region src/protocol.ts
+var FateRequestError = class extends Error {
+	constructor(code, message, options = {}) {
+		super(message);
+		this.name = "FateRequestError";
+		this.code = code;
+		this.issues = options.issues;
+		this.status = options.status ?? statusFromErrorCode(code);
+	}
+};
+const statusFromErrorCode = (code) => {
+	switch (code) {
+		case "BAD_REQUEST":
+		case "VALIDATION_ERROR": return 400;
+		case "UNAUTHORIZED": return 401;
+		case "FORBIDDEN": return 403;
+		case "NOT_FOUND": return 404;
+		case "INTERNAL_ERROR": return 500;
+	}
+};
+const errorCodeFromStatus = (status) => {
+	if (status === 400) return "BAD_REQUEST";
+	if (status === 401) return "UNAUTHORIZED";
+	if (status === 403) return "FORBIDDEN";
+	if (status === 404) return "NOT_FOUND";
+	return "INTERNAL_ERROR";
+};
+const toProtocolError = (error) => {
+	if (error instanceof FateRequestError) return {
+		code: error.code,
+		issues: error.issues,
+		message: error.message
+	};
+	if (error instanceof Error) return {
+		code: "INTERNAL_ERROR",
+		message: "Internal server error."
+	};
+	return {
+		code: "INTERNAL_ERROR",
+		message: "Internal server error."
+	};
+};
+//#endregion
+//#region src/liveTopics.ts
+const encodeTopicPart = (value) => encodeURIComponent(String(value));
+const normalizeConnectionArgs = (args) => {
+	const filtered = filterConnectionArgs(args);
+	if (!filtered) return;
+	const id = filtered.id;
+	return typeof id === "string" || typeof id === "number" ? {
+		...filtered,
+		id: String(id)
+	} : filtered;
+};
+const liveEntityTopic = (type, id) => `entity:${encodeTopicPart(type)}:${encodeTopicPart(id)}`;
+const liveConnectionTopic = (procedure, args) => `connection:${encodeTopicPart(procedure)}:${encodeTopicPart(hashArgs(normalizeConnectionArgs(args) ?? {}))}`;
+const liveGlobalConnectionTopic = (procedure) => `connection:${encodeTopicPart(procedure)}:*`;
+//#endregion
+export { errorCodeFromStatus as a, cloneArgs as c, hashArgs as d, paginationArgKeys as f, FateRequestError as i, combineArgsPayload as l, scopeArgsPayload as m, liveEntityTopic as n, toProtocolError as o, resolvedArgsFromPlan as p, liveGlobalConnectionTopic as r, applyArgsPayloadToPlan as s, liveConnectionTopic as t, filterConnectionArgs as u };

package/lib/{record-DnhZuvUe.mjs → record-AeZJC9fd.mjs}

@@ -1,5 +1,4 @@
 //#region src/record.ts
 const isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
-
 //#endregion
-export { isRecord as t };
+export { isRecord as t };

package/lib/record-ENh92gyb.d.mts

@@ -0,0 +1,315 @@
+import { t as AnyRecord } from "./types-Dz46PXr3.mjs";
+import { N as DataViewResult, S as ConnectionResult, k as DataView, l as SourceDefinition, t as SourceRegistry } from "./executor-BqwHdN3n.mjs";
+
+//#region src/liveTopics.d.ts
+declare const liveEntityTopic: (type: string, id: string | number) => string;
+declare const liveConnectionTopic: (procedure: string, args?: Record<string, unknown>) => string;
+declare const liveGlobalConnectionTopic: (procedure: string) => string;
+//#endregion
+//#region src/server/live.d.ts
+type LiveEventType = 'delete' | 'update';
+type LiveConnectionEventType = 'appendEdge' | 'appendNode' | 'deleteEdge' | 'insertEdgeAfter' | 'insertEdgeBefore' | 'invalidate' | 'prependEdge' | 'prependNode';
+type LiveSourceEvent = Readonly<{
+  changed?: ReadonlyArray<string>;
+  data?: unknown;
+  eventId?: string;
+  id: string | number;
+  type: LiveEventType;
+}>;
+type LiveConnectionSourceEvent = Readonly<{
+  cursor?: string;
+  eventId?: string;
+  id?: string | number;
+  node?: unknown;
+  nodeType?: string;
+  targetCursor?: string;
+  type: LiveConnectionEventType;
+}>;
+type LiveConnectionTarget = Readonly<{
+  args?: Record<string, unknown>;
+  procedure: string;
+}>;
+type LiveConnectionEmitOptions = Readonly<{
+  cursor?: string;
+  eventId?: string;
+  node?: unknown;
+  nodeType?: string;
+  targetCursor?: string;
+}>;
+type LiveConnectionHandle = Readonly<{
+  appendEdge: (nodeType: string, id: string | number, options?: LiveConnectionEmitOptions) => void;
+  appendNode: (nodeType: string, id: string | number, options?: LiveConnectionEmitOptions) => void;
+  deleteEdge: (nodeType: string, id: string | number, options?: {
+    eventId?: string;
+  }) => void;
+  emit: (type: LiveConnectionEventType, options?: LiveConnectionEmitOptions & {
+    id?: string | number;
+  }) => void;
+  insertEdgeAfter: (nodeType: string, id: string | number, targetCursor: string, options?: LiveConnectionEmitOptions) => void;
+  insertEdgeBefore: (nodeType: string, id: string | number, targetCursor: string, options?: LiveConnectionEmitOptions) => void;
+  invalidate: (options?: {
+    eventId?: string;
+  }) => void;
+  prependEdge: (nodeType: string, id: string | number, options?: LiveConnectionEmitOptions) => void;
+  prependNode: (nodeType: string, id: string | number, options?: LiveConnectionEmitOptions) => void;
+}>;
+type LiveEventBus = Readonly<{
+  connection: (procedure: string, args?: Record<string, unknown>) => LiveConnectionHandle;
+  delete: (type: string, id: string | number, options?: {
+    eventId?: string;
+  }) => void;
+  emit: (type: string, id: string | number, options?: {
+    changed?: ReadonlyArray<string>;
+    data?: unknown;
+    eventId?: string;
+    type?: LiveEventType;
+  }) => void;
+  listen?: (type: string, id: string | number, handler: (event: LiveSourceEvent) => void, options?: {
+    lastEventId?: string;
+    signal?: AbortSignal;
+  }) => () => void;
+  listenConnection?: (target: LiveConnectionTarget, handler: (event: LiveConnectionSourceEvent) => void, options?: {
+    lastEventId?: string;
+    signal?: AbortSignal;
+  }) => () => void;
+  subscribe: (type: string, id: string | number, options?: {
+    lastEventId?: string;
+    signal?: AbortSignal;
+  }) => AsyncIterable<readonly [LiveSourceEvent]>;
+  subscribeConnection: (target: LiveConnectionTarget, options?: {
+    lastEventId?: string;
+    signal?: AbortSignal;
+  }) => AsyncIterable<readonly [LiveConnectionSourceEvent]>;
+  update: (type: string, id: string | number, options?: {
+    changed?: ReadonlyArray<string>;
+    data?: unknown;
+    eventId?: string;
+  }) => void;
+}>;
+/**
+ * Creates a small in-memory event bus for Fate live view subscriptions.
+ *
+ * The bus signals that an entity changed and can optionally include changed
+ * field paths. The native live handler refetches the selected record, or only
+ * the changed selected fields when paths are provided, before sending it to
+ * clients. It does not persist events or replay events after reconnects; provide
+ * a durable custom bus for lossless `lastEventId` resume behavior.
+ */
+declare function createLiveEventBus(): LiveEventBus;
+//#endregion
+//#region src/server/http.d.ts
+type MaybePromise<T> = T | Promise<T>;
+type SourceResolver<Context> = {
+  getSource: <Item extends AnyRecord = AnyRecord>(target: DataView<Item> | SourceDefinition<Item, unknown>) => SourceDefinition<Item, unknown>;
+  registry: SourceRegistry<Context>;
+};
+type RootConfig = DataView<AnyRecord> | {
+  procedure?: string;
+  view: DataView<AnyRecord>;
+};
+type RootMap = Record<string, RootConfig>;
+type OperationInput = {
+  args?: Record<string, unknown>;
+  select: Array<string>;
+};
+type ResolverContext<Context, Input = unknown> = {
+  ctx: Context;
+  input: Input;
+  select: Array<string>;
+};
+type QueryResolver<Context, Args = Record<string, unknown> | undefined, Output = unknown> = (options: ResolverContext<Context, {
+  args?: Args;
+}>) => MaybePromise<Output>;
+type ListResolver<Context, Args = Record<string, unknown> | undefined, Output = unknown> = (options: ResolverContext<Context, {
+  args?: Args;
+}>) => MaybePromise<ConnectionResult<Output>>;
+type MutationResolver<Context, Input = unknown, Output = unknown> = (options: ResolverContext<Context, Input>) => MaybePromise<Output>;
+type QueryDefinition<Context, Args = Record<string, unknown> | undefined, Output = unknown> = {
+  resolve: QueryResolver<Context, Args, Output>;
+  type?: string;
+};
+type ListDefinition<Context, Args = Record<string, unknown> | undefined, Output = unknown> = {
+  defaultSize?: number;
+  resolve: ListResolver<Context, Args, Output>;
+  type?: string;
+};
+type SchemaLike = {
+  '~standard'?: {
+    validate: (value: unknown) => unknown;
+  };
+  parse?: (value: unknown) => unknown;
+};
+type MutationDefinition<Context, Input = unknown, Output = unknown> = {
+  input?: SchemaLike;
+  resolve: MutationResolver<Context, Input, Output>;
+  type: string;
+};
+type LiveConfig = LiveEventBus | {
+  bus: LiveEventBus;
+};
+type ContextOptions<AdapterContext> = {
+  adapterContext?: AdapterContext;
+  request: Request;
+};
+type FateServerOptions<Context, Roots extends RootMap, Queries extends Record<string, QueryDefinition<Context, any, any>>, Lists extends Record<string, ListDefinition<Context, any, any>>, Mutations extends Record<string, MutationDefinition<Context, any, any>>, AdapterContext> = {
+  context?: (options: ContextOptions<AdapterContext>) => MaybePromise<Context>;
+  lists?: Lists;
+  live?: false | LiveConfig;
+  mutations?: Mutations;
+  queries?: Queries;
+  roots: Roots;
+  sources: SourceResolver<Context>;
+};
+type RootView<Root> = Root extends DataView<AnyRecord> ? Root : Root extends {
+  view: infer View extends DataView<AnyRecord>;
+} ? View : never;
+type RootProcedure<_Root, Name extends string> = Name;
+type RootOutput<Root> = RootView<Root> extends infer View extends DataView<AnyRecord> ? View['kind'] extends 'list' ? ConnectionResult<DataViewResult<View>> : DataViewResult<View> | null : never;
+type RootLists<Roots extends RootMap> = { [K in keyof Roots as RootView<Roots[K]>['kind'] extends 'list' ? RootProcedure<Roots[K], K & string> : never]: {
+  input: OperationInput;
+  output: RootOutput<Roots[K]>;
+} };
+type RootQueries<Roots extends RootMap> = { [K in keyof Roots as RootView<Roots[K]>['kind'] extends 'list' ? never : RootProcedure<Roots[K], K & string>]: {
+  input: OperationInput;
+  output: RootOutput<Roots[K]>;
+} };
+type QueryAPI<Queries extends Record<string, QueryDefinition<any, any, any>>> = { [K in keyof Queries]: Queries[K] extends QueryDefinition<any, infer Args, infer Output> ? {
+  input: {
+    args?: Args;
+    select: Array<string>;
+  };
+  output: Awaited<Output>;
+} : never };
+type ListAPI<Lists extends Record<string, ListDefinition<any, any, any>>> = { [K in keyof Lists]: Lists[K] extends ListDefinition<any, infer Args, infer Output> ? {
+  input: {
+    args?: Args;
+    select: Array<string>;
+  };
+  output: ConnectionResult<Awaited<Output>>;
+} : never };
+type MutationAPI<Mutations extends Record<string, MutationDefinition<any, any, any>>> = { [K in keyof Mutations]: Mutations[K] extends MutationDefinition<any, infer Input, infer Output> ? {
+  entity: Mutations[K]['type'];
+  input: Input;
+  output: Awaited<Output>;
+} : never };
+type NativeFateAPI<Roots extends RootMap, Queries extends Record<string, QueryDefinition<any, any, any>>, Lists extends Record<string, ListDefinition<any, any, any>>, Mutations extends Record<string, MutationDefinition<any, any, any>>> = {
+  lists: RootLists<Roots> & ListAPI<Lists>;
+  mutations: MutationAPI<Mutations>;
+  queries: RootQueries<Roots> & QueryAPI<Queries>;
+};
+type FateServer<API, AdapterContext = unknown> = {
+  readonly __api?: API;
+  handleLiveRequest(request: Request, adapterContext?: AdapterContext): Promise<Response>;
+  handleRequest(request: Request, adapterContext?: AdapterContext): Promise<Response>;
+  readonly manifest: FateServerManifest;
+};
+type InferFateAPI<Server> = Server extends {
+  readonly __api?: infer API;
+} ? API : never;
+type FateServerManifest = Readonly<{
+  lists: Record<string, {
+    type: string;
+  }>;
+  live: Record<string, true>;
+  mutations: Record<string, {
+    type: string;
+  }>;
+  queries: Record<string, {
+    type: string;
+  }>;
+  types: Record<string, true>;
+}>;
+declare function createFateServer<Context = unknown, Roots extends RootMap = RootMap, Queries extends Record<string, QueryDefinition<Context, any, any>> = Record<never, never>, Lists extends Record<string, ListDefinition<Context, any, any>> = Record<never, never>, Mutations extends Record<string, MutationDefinition<Context, any, any>> = Record<never, never>, AdapterContext = unknown>({
+  context,
+  lists,
+  live,
+  mutations,
+  queries,
+  roots,
+  sources
+}: FateServerOptions<Context, Roots, Queries, Lists, Mutations, AdapterContext>): FateServer<NativeFateAPI<Roots, Queries, Lists, Mutations>, AdapterContext>;
+declare function createFateFetchHandler<AdapterContext>(server: FateServer<unknown, AdapterContext>): (request: Request, adapterContext?: AdapterContext) => Promise<Response>;
+declare function createHonoFateHandler<Context>(server: FateServer<unknown, Context>): (context: Context & {
+  req: {
+    raw: Request;
+  };
+}) => Promise<Response>;
+//#endregion
+//#region src/protocol.d.ts
+type FateProtocolVersion = 1;
+type FateOperationKind = 'byId' | 'list' | 'mutation' | 'query';
+type FateOperation = Readonly<{
+  args?: Record<string, unknown>;
+  id: string;
+  ids?: Array<string | number>;
+  input?: unknown;
+  kind: FateOperationKind;
+  name?: string;
+  select: Array<string>;
+  type?: string;
+}>;
+type FateOperationResult = Readonly<{
+  data: unknown;
+  id: string;
+  ok: true;
+}> | Readonly<{
+  error: FateProtocolError;
+  id: string;
+  ok: false;
+}>;
+type FateProtocolRequest = Readonly<{
+  operations: Array<FateOperation>;
+  version: FateProtocolVersion;
+}>;
+type FateProtocolResponse = Readonly<{
+  results: Array<FateOperationResult>;
+  version: FateProtocolVersion;
+}>;
+type FateLiveDataEvent = Readonly<{
+  data: unknown;
+  delete?: false;
+  select?: Array<string>;
+  type?: 'data' | 'update';
+}>;
+type FateLiveDeleteEvent = Readonly<{
+  delete: true;
+  id?: string | number;
+  type?: 'delete';
+}>;
+type FateLiveEvent = FateLiveDataEvent | FateLiveDeleteEvent;
+type FateLiveConnectionEvent = Readonly<{
+  edge: {
+    cursor?: string;
+    node: unknown;
+  };
+  nodeType: string;
+  targetCursor?: string;
+  type: 'appendEdge' | 'appendNode' | 'insertEdgeAfter' | 'insertEdgeBefore' | 'prependEdge' | 'prependNode';
+}> | Readonly<{
+  id: string | number;
+  nodeType: string;
+  type: 'deleteEdge';
+}> | Readonly<{
+  type: 'invalidate';
+}>;
+type FateProtocolErrorCode = 'BAD_REQUEST' | 'FORBIDDEN' | 'INTERNAL_ERROR' | 'NOT_FOUND' | 'UNAUTHORIZED' | 'VALIDATION_ERROR';
+type FateProtocolError = Readonly<{
+  code: FateProtocolErrorCode;
+  issues?: unknown;
+  message: string;
+  path?: string;
+}>;
+declare class FateRequestError extends Error {
+  readonly code: FateProtocolErrorCode;
+  readonly issues?: unknown;
+  readonly status: number;
+  constructor(code: FateProtocolErrorCode, message: string, options?: {
+    issues?: unknown;
+    status?: number;
+  });
+}
+//#endregion
+//#region src/record.d.ts
+declare const isRecord: (value: unknown) => value is AnyRecord;
+//#endregion
+export { liveGlobalConnectionTopic as C, liveEntityTopic as S, LiveEventBus as _, FateProtocolRequest as a, createLiveEventBus as b, FateServer as c, NativeFateAPI as d, createFateFetchHandler as f, LiveConnectionSourceEvent as g, LiveConnectionEventType as h, FateOperation as i, FateServerManifest as l, createHonoFateHandler as m, FateLiveConnectionEvent as n, FateProtocolResponse as o, createFateServer as p, FateLiveEvent as r, FateRequestError as s, isRecord as t, InferFateAPI as u, LiveEventType as v, liveConnectionTopic as x, LiveSourceEvent as y };