foldkit-remote 0.21.0 → 0.22.0

package/dist/policy-DsWHmIAq.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy-DsWHmIAq.d.ts","names":[],"sources":["../src/policy.ts"],"mappings":";KAQY;;;WAEG;;;;;;;WAKA;WAAuC;;;;WAEvC;;cAEF;;;aAES;;;EAGY,uBAAA;aAAW;QAAmB;;;aAMzC;;;EAGJ,SAAA,QAAA,cAAY,gBAAgB;;;;;;EAgBzB,YAAA,QAAA"}

package/dist/policy.d.ts

@@ -0,0 +1,2 @@
+import { t as RemotePolicy } from "./policy-DsWHmIAq.js";
+export { RemotePolicy };

package/dist/policy.js

@@ -0,0 +1,32 @@
+// src/policy.ts
+const RemotePolicy = {
+	/** Fetch only what the store lacks. */
+	cacheFirst: { _tag: "CacheFirst" },
+	/** Keep present values visible, read as `Refreshing`, and refetch an entry older than `maxAge` ms. */
+	staleWhileRevalidate: (options) => ({
+		_tag: "StaleWhileRevalidate",
+		maxAge: options.maxAge
+	}),
+	/** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */
+	networkOnly: { _tag: "NetworkOnly" },
+	/** The planner options a policy compiles to at `now`. */
+	toPlan: (policy, now) => {
+		switch (policy._tag) {
+			case "CacheFirst": return {};
+			case "StaleWhileRevalidate": return { freshness: {
+				now,
+				freshness: policy.maxAge
+			} };
+			case "NetworkOnly": return { force: true };
+		}
+	},
+	/**
+	* Whether a read under this policy may refetch fields the store already
+	* holds, so an observer marks them stale (read as `Refreshing`) while the
+	* request is pending.
+	*/
+	refreshes: (policy) => policy._tag !== "CacheFirst"
+};
+export { RemotePolicy };
+
+//# sourceMappingURL=policy.js.map

package/dist/policy.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"policy.js","names":[],"sources":["../src/policy.ts"],"sourcesContent":["/**\n * Request policies: how a read treats fields the store already holds. A policy\n * compiles to planner options; it is not a second cache. `Remote.observe` and\n * `Remote.prefetch` take one, and the planner itself stays pure and\n * time-injected.\n */\nimport type { PlanOptions } from './plan.js'\n\nexport type RemotePolicy =\n  /** Fetch only fields the store lacks (missing, stale, or re-windowed). */\n  | { readonly _tag: 'CacheFirst' }\n  /**\n   * Keep present values visible, read them as `Refreshing`, and refetch an\n   * entry older than `maxAge` milliseconds.\n   */\n  | { readonly _tag: 'StaleWhileRevalidate'; readonly maxAge: number }\n  /** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */\n  | { readonly _tag: 'NetworkOnly' }\n\nexport const RemotePolicy = {\n  /** Fetch only what the store lacks. */\n  cacheFirst: { _tag: 'CacheFirst' } as const satisfies RemotePolicy,\n\n  /** Keep present values visible, read as `Refreshing`, and refetch an entry older than `maxAge` ms. */\n  staleWhileRevalidate: (options: { readonly maxAge: number }): RemotePolicy => ({\n    _tag: 'StaleWhileRevalidate',\n    maxAge: options.maxAge,\n  }),\n\n  /** Fetch every selected field regardless of coverage; cached values stay visible meanwhile. */\n  networkOnly: { _tag: 'NetworkOnly' } as const satisfies RemotePolicy,\n\n  /** The planner options a policy compiles to at `now`. */\n  toPlan: (policy: RemotePolicy, now: number): PlanOptions => {\n    switch (policy._tag) {\n      case 'CacheFirst':\n        return {}\n      case 'StaleWhileRevalidate':\n        return { freshness: { now, freshness: policy.maxAge } }\n      case 'NetworkOnly':\n        return { force: true }\n    }\n  },\n\n  /**\n   * Whether a read under this policy may refetch fields the store already\n   * holds, so an observer marks them stale (read as `Refreshing`) while the\n   * request is pending.\n   */\n  refreshes: (policy: RemotePolicy): boolean => policy._tag !== 'CacheFirst',\n}\n"],"mappings":";AAmBA,MAAa,eAAe;;CAE1B,YAAY,EAAE,MAAM,aAAa;;CAGjC,uBAAuB,aAAwD;EAC7E,MAAM;EACN,QAAQ,QAAQ;CAClB;;CAGA,aAAa,EAAE,MAAM,cAAc;;CAGnC,SAAS,QAAsB,QAA6B;EAC1D,QAAQ,OAAO,MAAf;GACE,KAAK,cACH,OAAO,CAAC;GACV,KAAK,wBACH,OAAO,EAAE,WAAW;IAAE;IAAK,WAAW,OAAO;GAAO,EAAE;GACxD,KAAK,eACH,OAAO,EAAE,OAAO,KAAK;EACzB;CACF;;;;;;CAOA,YAAY,WAAkC,OAAO,SAAS;AAChE"}

package/dist/{port.d.mts → port.d.ts}

@@ -1,4 +1,5 @@
-import { kn as RemoteClient } from "./index-YyucgTYm.mjs";
+import { t as RemoteClient } from "./client-B055kQuP.js";
+import "./index.js";
 import { Effect, Layer } from "effect";
 import { RpcClient } from "effect/rpc";
 import * as WorkerRunner from "effect/workers/WorkerRunner";
@@ -23,4 +24,4 @@ export declare const portRunner: (served: MessagePort) => {
   readonly platform: WorkerRunner.WorkerRunnerPlatform['Service'];
   readonly closed: Effect.Effect<void>;
 };
-//# sourceMappingURL=port.d.mts.map
+//# sourceMappingURL=port.d.ts.map

package/dist/port.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.d.ts","names":[],"sources":["../src/port.ts"],"mappings":";;;;;;;;;;;;;qBA8Ca,eAAY,YACX,gBACX,MAAM,MAAM,UAAU,UAAU;;qBAWtB,OAAI,YAAgB,gBAAc,MAAM,MAAM;;;;;;;qBAc9C,aAAU,QACb;WAEC,UAAU,aAAa;WACvB,QAAQ,OAAO"}

package/dist/{port.mjs → port.js}

@@ -1,4 +1,5 @@
-import { gn as RemoteRpc, t as Remote } from "./src-lVP_7bf4.mjs";
+import { RemoteRpc } from "./wire.js";
+import { Remote } from "./index.js";
 import { Deferred, Effect, Exit, Layer, Queue, Scope } from "effect";
 import { RpcClient } from "effect/rpc";
 import * as Worker from "effect/workers/Worker";
@@ -77,4 +78,4 @@ const portRunner = (served) => {
 };
 export { port, portProtocol, portRunner };
 
-//# sourceMappingURL=port.mjs.map
+//# sourceMappingURL=port.js.map

package/dist/port.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"port.js","names":[],"sources":["../src/port.ts"],"sourcesContent":["/**\n * `foldkit-remote/port`: Remote over a `MessagePort`, for a server in a\n * worker or in the page (a sandbox). It speaks Effect's own RPC worker\n * protocol over the port, so reads, queries, mutations and live streams, their\n * typed errors and interruption all cross it; `foldkit-remote-server/port`\n * serves the other end.\n *\n * Built on `effect/workers` alone: a `MessagePort` platform for the client and\n * a one-port runner for the server, no browser package.\n */\nimport { Deferred, Effect, Exit, Layer, Queue, Scope } from 'effect'\nimport { RpcClient } from 'effect/rpc'\nimport * as Worker from 'effect/workers/Worker'\nimport type { WorkerError } from 'effect/workers/WorkerError'\nimport * as WorkerRunner from 'effect/workers/WorkerRunner'\nimport { Remote, type RemoteClient } from './index.js'\nimport { RemoteRpc } from './wire.js'\n\nconst platform = Worker.makePlatform<MessagePort>()({\n  // Closing the client's scope tells the server the conversation is over.\n  setup: ({ worker, scope }) =>\n    Effect.as(\n      Scope.addFinalizer(\n        scope,\n        Effect.sync(() => worker.postMessage([1])),\n      ),\n      worker,\n    ),\n  listen: ({ port, emit, scope }) => {\n    const onMessage = (event: MessageEvent) => emit(event.data)\n    port.addEventListener('message', onMessage)\n    port.start()\n    return Scope.addFinalizer(\n      scope,\n      Effect.sync(() => port.removeEventListener('message', onMessage)),\n    )\n  },\n})\n\n/**\n * Effect's RPC worker protocol over a `MessagePort`: what `port` runs on, for\n * an RPC client of `RemoteRpc` made by hand. `open` is called for each\n * connection the protocol makes (once, and again if it restarts), so it opens\n * a new conversation each time, such as a `MessageChannel` whose other port\n * goes to the server.\n */\nexport const portProtocol = (\n  open: () => MessagePort,\n): Layer.Layer<RpcClient.Protocol, WorkerError> =>\n  RpcClient.layerProtocolWorker({ size: 1 }).pipe(\n    Layer.provide(\n      Layer.merge(\n        Layer.succeed(Worker.WorkerPlatform)(platform),\n        Worker.layerSpawner(() => open()),\n      ),\n    ),\n  )\n\n/** Remote's client over a `MessagePort`: `portProtocol` under `Remote.clientLayer`. */\nexport const port = (open: () => MessagePort): Layer.Layer<RemoteClient> =>\n  Layer.unwrap(Effect.map(RpcClient.make(RemoteRpc), client => Remote.clientLayer(client))).pipe(\n    Layer.provide(portProtocol(open)),\n    // A port that cannot be set up is a broken sandbox, not a failed read:\n    // each call's own failure is a Remote error, as over HTTP.\n    Layer.orDie,\n  )\n\n/**\n * The server's side of one port: Effect's `WorkerRunnerPlatform` over a single\n * `MessagePort`, for `RpcServer.layerProtocolWorkerRunner`, and `closed`,\n * which completes when the client closes its end. `foldkit-remote-server/port`\n * uses it.\n */\nexport const portRunner = (\n  served: MessagePort,\n): {\n  readonly platform: WorkerRunner.WorkerRunnerPlatform['Service']\n  readonly closed: Effect.Effect<void>\n} => {\n  const closed = Deferred.makeUnsafe<void>()\n  const platform: WorkerRunner.WorkerRunnerPlatform['Service'] = {\n    start: <O, I>() =>\n      Effect.gen(function* () {\n        const disconnects = yield* Queue.make<number>()\n        const sendUnsafe = (_: number, message: O, transfer?: ReadonlyArray<unknown>) =>\n          served.postMessage([1, message], {\n            transfer: [...(transfer ?? [])] as Array<Transferable>,\n          })\n        const run = <A, E, R>(\n          handler: (portId: number, message: I) => Effect.Effect<A, E, R> | void,\n        ) =>\n          Effect.scopedWith(scope =>\n            Effect.gen(function* () {\n              const fork = Effect.runForkWith(yield* Effect.context<R>())\n              const onMessage = (event: MessageEvent) => {\n                const message = event.data as WorkerRunner.PlatformMessage<I>\n                if (message[0] === 1) {\n                  Deferred.doneUnsafe(closed, Exit.void)\n                  return\n                }\n                const result = handler(0, message[1])\n                if (Effect.isEffect(result)) fork(result)\n              }\n              served.addEventListener('message', onMessage)\n              served.start()\n              served.postMessage([0])\n              yield* Scope.addFinalizer(\n                scope,\n                Effect.sync(() => {\n                  served.removeEventListener('message', onMessage)\n                  served.close()\n                }),\n              )\n              yield* Deferred.await(closed)\n            }),\n          )\n        const runner: WorkerRunner.WorkerRunner<O, I> = {\n          run,\n          send: (portId, message, transfer) =>\n            Effect.sync(() => sendUnsafe(portId, message, transfer)),\n          sendUnsafe,\n          disconnects,\n        }\n        return runner\n      }),\n  }\n  return { platform, closed: Deferred.await(closed) }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;AAkBA,MAAM,WAAW,OAAO,aAA0B,CAAC,CAAC;CAElD,QAAQ,EAAE,QAAQ,YAChB,OAAO,GACL,MAAM,aACJ,OACA,OAAO,WAAW,OAAO,YAAY,CAAC,CAAC,CAAC,CAAC,CAC3C,GACA,MACF;CACF,SAAS,EAAE,MAAM,MAAM,YAAY;EACjC,MAAM,aAAa,UAAwB,KAAK,MAAM,IAAI;EAC1D,KAAK,iBAAiB,WAAW,SAAS;EAC1C,KAAK,MAAM;EACX,OAAO,MAAM,aACX,OACA,OAAO,WAAW,KAAK,oBAAoB,WAAW,SAAS,CAAC,CAClE;CACF;AACF,CAAC;;;;;;;;AASD,MAAa,gBACX,SAEA,UAAU,oBAAoB,EAAE,MAAM,EAAE,CAAC,CAAC,CAAC,KACzC,MAAM,QACJ,MAAM,MACJ,MAAM,QAAQ,OAAO,cAAc,CAAC,CAAC,QAAQ,GAC7C,OAAO,mBAAmB,KAAK,CAAC,CAClC,CACF,CACF;;AAGF,MAAa,QAAQ,SACnB,MAAM,OAAO,OAAO,IAAI,UAAU,KAAK,SAAS,IAAG,WAAU,OAAO,YAAY,MAAM,CAAC,CAAC,CAAC,CAAC,KACxF,MAAM,QAAQ,aAAa,IAAI,CAAC,GAGhC,MAAM,KACR;;;;;;;AAQF,MAAa,cACX,WAIG;CACH,MAAM,SAAS,SAAS,WAAiB;CA+CzC,OAAO;EAAE,UAAA,EA7CP,aACE,OAAO,IAAI,aAAa;GACtB,MAAM,cAAc,OAAO,MAAM,KAAa;GAC9C,MAAM,cAAc,GAAW,SAAY,aACzC,OAAO,YAAY,CAAC,GAAG,OAAO,GAAG,EAC/B,UAAU,CAAC,GAAI,YAAY,CAAC,CAAE,EAChC,CAAC;GACH,MAAM,OACJ,YAEA,OAAO,YAAW,UAChB,OAAO,IAAI,aAAa;IACtB,MAAM,OAAO,OAAO,YAAY,OAAO,OAAO,QAAW,CAAC;IAC1D,MAAM,aAAa,UAAwB;KACzC,MAAM,UAAU,MAAM;KACtB,IAAI,QAAQ,OAAO,GAAG;MACpB,SAAS,WAAW,QAAQ,KAAK,IAAI;MACrC;KACF;KACA,MAAM,SAAS,QAAQ,GAAG,QAAQ,EAAE;KACpC,IAAI,OAAO,SAAS,MAAM,GAAG,KAAK,MAAM;IAC1C;IACA,OAAO,iBAAiB,WAAW,SAAS;IAC5C,OAAO,MAAM;IACb,OAAO,YAAY,CAAC,CAAC,CAAC;IACtB,OAAO,MAAM,aACX,OACA,OAAO,WAAW;KAChB,OAAO,oBAAoB,WAAW,SAAS;KAC/C,OAAO,MAAM;IACf,CAAC,CACH;IACA,OAAO,SAAS,MAAM,MAAM;GAC9B,CAAC,CACH;GAQF,OAAO;IANL;IACA,OAAO,QAAQ,SAAS,aACtB,OAAO,WAAW,WAAW,QAAQ,SAAS,QAAQ,CAAC;IACzD;IACA;GAEU;EACd,CAAC,EAEW;EAAG,QAAQ,SAAS,MAAM,MAAM;CAAE;AACpD"}

package/dist/query-BuIU93xA.d.ts

@@ -0,0 +1,141 @@
+import { r as Cursor } from "./connection-BRyaJy89.js";
+import { F as SchemaOrFields, L as TypeOf } from "./optimistic-CECsfNGY.js";
+import { Schema } from "effect";
+import { AnyEntity, AnyQuery, InputExpr, Query } from "foldkit-entity";
+type LiveInsertion = 'visible' | 'boundary' | 'invalidate' | 'ignore';
+interface LivePolicy {
+  readonly prepend?: LiveInsertion;
+  readonly append?: LiveInsertion;
+}
+interface ConnectionSpec<Entity extends string = string> {
+  readonly entity: Entity;
+  readonly edgeKey?: Schema.Schema<unknown>;
+  readonly live?: LivePolicy;
+}
+interface QueryWindow {
+  readonly first?: number | undefined;
+  readonly last?: number | undefined;
+  readonly after?: Cursor | undefined;
+  readonly before?: Cursor | undefined;
+}
+interface QueryRef<Name extends string, Input> {
+  readonly query: Name;
+  readonly input: Input;
+  /** The input codec, so a `QueryRef` can encode itself without its descriptor. */
+  readonly Input: Schema.Codec<Input>;
+  readonly window: QueryWindow;
+  /** Connection identity: descriptor + canonical input, excluding the window. */
+  readonly identity: string;
+}
+interface QueryDescriptor<Name extends string, Input, Result> {
+  readonly name: Name;
+  readonly Input: Schema.Codec<Input>;
+  readonly Result: Result;
+  readonly ref: (input: Input) => QueryRef<Name, Input>;
+  /**
+   * What the query means, when it was declared with `Query.define`: the rows it
+   * is about, as a value an interpreter can compile. A descriptor from
+   * `Query.make` has none — its meaning lives in whatever the server registered
+   * to answer it — and a source is free to answer either.
+   */
+  readonly body?: AnyQuery | undefined;
+}
+/**
+ * The inputs of a definition's body: one placeholder per key of `Input`, typed
+ * as that key's value. A body is built once, so these stand for what the query
+ * will be given rather than being it.
+ */
+type QueryInputs<Input> = { readonly [K in keyof Input & string]: InputExpr<Input[K]>; };
+/**
+ * What separates a query's name from its canonical encoded input in a
+ * connection identity.
+ *
+ * NUL, because `JSON.stringify` escapes it inside a string (`\u0000`) and a
+ * query name is a TypeScript identifier — so the first occurrence is always the
+ * boundary, and a name or an input value cannot forge one. Anything recovering
+ * the query from an identity splits here.
+ */
+declare const IDENTITY_SEPARATOR = "\0";
+/** Stable stringify: object keys sorted, undefined-valued keys dropped, so equal inputs encode equally. */
+declare const stableStringify: (value: unknown) => string;
+/**
+ * A connection's identity: the query's name and its input, encoded and
+ * canonical. What the client keys a list by, and what a server that runs a
+ * query from its request (a live list) names the list as.
+ */
+declare const queryIdentity: (query: string, encodedInput: unknown) => string;
+/**
+ * `Result: Project` (or anything with the entity's `name`, as `Query.connection`
+ * takes) means a connection over it; a `ConnectionSpec` names its `entity`
+ * instead and is the result as given.
+ */
+type ResultOf<Result> = Result extends {
+  readonly name: infer Entity extends string;
+} ? ConnectionSpec<Entity> : Result;
+/** A relational `Query` over one Entity, as `Query.define`'s body returns. */
+type RelationalQueryOf<E extends AnyEntity> = ReturnType<typeof Query.from<E>>;
+declare const Query$1: {
+  from: <E extends AnyEntity>(entity: E) => Query<E>;
+  where: <const P extends ReadonlyArray<import("foldkit-entity").Predicate>>(...predicates: P) => <E extends AnyEntity>(self: Query<E> & (string extends import("foldkit-entity").ReadsOf<P[number]> ? unknown : [import("foldkit-entity").ReadsOf<P[number]>] extends [E["name"]] ? unknown : import("foldkit-entity").Invalid<`foldkit-entity: a predicate reads ${Exclude<import("foldkit-entity").ReadsOf<P[number]>, E["name"]>}, but the query is from ${E["name"]}`>)) => Query<E>;
+  orderBy: <const T extends ReadonlyArray<import("foldkit-entity").Ordering>>(...terms: T) => <E extends AnyEntity>(self: Query<E> & (string extends import("foldkit-entity").ReadsOf<T[number]> ? unknown : [import("foldkit-entity").ReadsOf<T[number]>] extends [E["name"]] ? unknown : import("foldkit-entity").Invalid<`foldkit-entity: an ordering term reads ${Exclude<import("foldkit-entity").ReadsOf<T[number]>, E["name"]>}, but the query is from ${E["name"]}`>)) => Query<E>;
+  orderFor: (self: AnyQuery, input: Readonly<Record<string, unknown>>) => ReadonlyArray<import("foldkit-entity").OrderTerm>;
+  placement: (self: AnyQuery, input: Readonly<Record<string, unknown>>, options?: {
+    readonly operators?: import("foldkit-entity").OperatorTable | undefined;
+  }) => import("foldkit-entity").Placement;
+  operators: (self: AnyQuery) => ReadonlyArray<string>;
+  dependencies: (self: AnyQuery) => import("foldkit-entity").QueryDependencies;
+  unsupported: (self: AnyQuery, supported: ReadonlyArray<import("foldkit-entity").Operation>, operators?: import("foldkit-entity").OperatorTable) => ReadonlyArray<string>;
+  show: (self: AnyQuery) => string;
+  /** Declares the entity and options a query's result is a connection over. */
+  connection: <Entity extends string>(entity: {
+    readonly name: Entity;
+  }, options?: {
+    readonly edgeKey?: Schema.Schema<unknown>;
+    readonly live?: LivePolicy;
+  }) => ConnectionSpec<Entity>;
+  /**
+   * Declares a query. `Input` is a codec or the fields of the `Schema.Struct` it
+   * would be; `Result` is a `Query.connection(...)`, or the entity the result is
+   * a connection over.
+   */
+  make: <const Name extends string, Input extends SchemaOrFields, Result>(name: Name, config: {
+    readonly Input: Input;
+    readonly Result: Result;
+  }) => QueryDescriptor<Name, TypeOf<Input>, ResultOf<Result>>;
+  /**
+   * Declares a query by what it means. The body is built once, here, and the
+   * `input` it is given holds placeholders rather than values — there is
+   * nothing yet to branch on, so a condition that depends on what was passed is
+   * a comparison over the placeholder:
+   *
+   * ```ts
+   * const PostsBySlug = Query.define('PostsBySlug', { slug: Schema.String }, ({ input }) =>
+   *   Query.from(Post).pipe(
+   *     Query.where(Expr.eq(Post.fields.slug, input.slug)),
+   *     Query.orderBy(Order.asc(Post.fields.id)),
+   *   ),
+   * )
+   * ```
+   *
+   * What comes back is an ordinary `QueryDescriptor` — the same name, `Input`,
+   * `ref` and connection identity `Query.make` gives — carrying its `body`
+   * besides. A server can compile that body instead of being told the same
+   * thing again in its own dialect, and one that would rather answer the query
+   * its own way still can.
+   *
+   * The result is a connection over the Entity the body reads, so it is not
+   * named twice.
+   */
+  define: <const Name extends string, Input extends SchemaOrFields, E extends AnyEntity>(name: Name, Input: Input, body: (context: {
+    readonly input: QueryInputs<TypeOf<Input>>;
+  }) => RelationalQueryOf<E>, options?: {
+    readonly edgeKey?: Schema.Schema<unknown>;
+    readonly live?: LivePolicy;
+  }) => QueryDescriptor<Name, TypeOf<Input>, ConnectionSpec<E['name']>>;
+  first: (count: number) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  last: (count: number) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  after: (cursor: Cursor) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+  before: (cursor: Cursor) => <R extends QueryRef<string, unknown>>(ref: R) => R;
+};
+export { Query$1 as a, QueryRef as c, queryIdentity as d, stableStringify as f, LivePolicy as i, QueryWindow as l, IDENTITY_SEPARATOR as n, QueryDescriptor as o, LiveInsertion as r, QueryInputs as s, ConnectionSpec as t, ResultOf as u };
+//# sourceMappingURL=query-BuIU93xA.d.ts.map

package/dist/query-BuIU93xA.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query-BuIU93xA.d.ts","names":["RelationalQuery","Query"],"sources":["../src/query.ts"],"mappings":";;;;KAgBY;UAEK;WACN,UAAU;WACV,SAAS;;UAGH,eAAe;WACrB,QAAQ;WACR,UAAU,OAAO;WACjB,OAAO;;UAGD;WACN;WACA;WACA,QAAQ;WACR,SAAS;;UAGH,SAAS,qBAAqB;WACpC,OAAO;WACP,OAAO;;WAEP,OAAO,OAAO,MAAM;WACpB,QAAQ;;WAER;;UAGM,gBAAgB,qBAAqB,OAAO;WAClD,MAAM;WACN,OAAO,OAAO,MAAM;WACpB,QAAQ;WACR,MAAM,OAAO,UAAU,SAAS,MAAM;;;;;;;WAOtC,OAAO;;;;;;;KAQN,YAAY,qBACZ,WAAW,iBAAiB,UAAU,MAAM;;;;;;;;;;cAY3C;;cAGA,kBAAe;;;;;;cAiBf,gBAAa,eAAiB;;;;;;KAQ/B,SAAS,UAAU;WAA0B,YAAY;IACjE,eAAe,UACf;;KA0CC,kBAAkB,UAAU,aAAa,kBAAkBA,MAAgB,KAAK;cAExEC;;;;;;;;;;;;;EAIE,aAAA,uBAAqB;aACb,MAAM;KAAQ;aACZ,UAAU,OAAO;aAA0B,OAAO;QACtE,eAAe;;;;;;EAWX,aAAM,qBAAqB,cAAc,gBAAgB,QAAM,MAC9D,MAAI;aACS,OAAO;aAAgB,QAAQ;QACjD,gBAAgB,MAAM,OAAO,QAAQ,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;EA2CxC,eAAM,qBAAqB,cAAc,gBAAgB,UAAU,WAAS,MAC7E,MAAI,OACH,OAAK,OACL;aAAoB,OAAO,YAAY,OAAO;QAAc,kBAAkB,IAAE;aAClE,UAAU,OAAO;aAA0B,OAAO;QACtE,gBAAgB,MAAM,OAAO,QAAQ,eAAe;EAW7C,QAAA,mBACP,UAAU,2BAAyB,KAAO,MAAI;EAMvC,OAAA,mBACP,UAAU,2BAAyB,KAAO,MAAI;EAMtC,QAAA,QAAA,YACR,UAAU,2BAAyB,KAAO,MAAI;EAMtC,SAAA,QAAA,YACR,UAAU,2BAAyB,KAAO,MAAI"}

package/dist/query.d.ts

@@ -0,0 +1,2 @@
+import { a as Query, c as QueryRef, d as queryIdentity, f as stableStringify, i as LivePolicy, l as QueryWindow, n as IDENTITY_SEPARATOR, o as QueryDescriptor, r as LiveInsertion, s as QueryInputs, t as ConnectionSpec, u as ResultOf } from "./query-BuIU93xA.js";
+export { ConnectionSpec, IDENTITY_SEPARATOR, LiveInsertion, LivePolicy, Query, QueryDescriptor, QueryInputs, QueryRef, QueryWindow, ResultOf, queryIdentity, stableStringify };

package/dist/query.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.js","names":["RelationalQuery"],"sources":["../src/query.ts"],"sourcesContent":["/**\n * Queries and connections. A connection's identity is its descriptor plus the\n * canonical encoded filter/sort input — **never** the pagination window, so\n * `first(25)` and `after(cursor).first(25)` address the same logical connection.\n */\nimport { Schema } from 'effect'\nimport {\n  Expr,\n  Query as RelationalQuery,\n  type AnyEntity,\n  type AnyQuery,\n  type InputExpr,\n} from 'foldkit-entity'\nimport type { Cursor } from './connection.js'\nimport { schemaOf, type SchemaOrFields, type TypeOf } from './mutation.js'\n\nexport type LiveInsertion = 'visible' | 'boundary' | 'invalidate' | 'ignore'\n\nexport interface LivePolicy {\n  readonly prepend?: LiveInsertion\n  readonly append?: LiveInsertion\n}\n\nexport interface ConnectionSpec<Entity extends string = string> {\n  readonly entity: Entity\n  readonly edgeKey?: Schema.Schema<unknown>\n  readonly live?: LivePolicy\n}\n\nexport interface QueryWindow {\n  readonly first?: number | undefined\n  readonly last?: number | undefined\n  readonly after?: Cursor | undefined\n  readonly before?: Cursor | undefined\n}\n\nexport interface QueryRef<Name extends string, Input> {\n  readonly query: Name\n  readonly input: Input\n  /** The input codec, so a `QueryRef` can encode itself without its descriptor. */\n  readonly Input: Schema.Codec<Input>\n  readonly window: QueryWindow\n  /** Connection identity: descriptor + canonical input, excluding the window. */\n  readonly identity: string\n}\n\nexport interface QueryDescriptor<Name extends string, Input, Result> {\n  readonly name: Name\n  readonly Input: Schema.Codec<Input>\n  readonly Result: Result\n  readonly ref: (input: Input) => QueryRef<Name, Input>\n  /**\n   * What the query means, when it was declared with `Query.define`: the rows it\n   * is about, as a value an interpreter can compile. A descriptor from\n   * `Query.make` has none — its meaning lives in whatever the server registered\n   * to answer it — and a source is free to answer either.\n   */\n  readonly body?: AnyQuery | undefined\n}\n\n/**\n * The inputs of a definition's body: one placeholder per key of `Input`, typed\n * as that key's value. A body is built once, so these stand for what the query\n * will be given rather than being it.\n */\nexport type QueryInputs<Input> = {\n  readonly [K in keyof Input & string]: InputExpr<Input[K]>\n}\n\n/**\n * What separates a query's name from its canonical encoded input in a\n * connection identity.\n *\n * NUL, because `JSON.stringify` escapes it inside a string (`\\u0000`) and a\n * query name is a TypeScript identifier — so the first occurrence is always the\n * boundary, and a name or an input value cannot forge one. Anything recovering\n * the query from an identity splits here.\n */\nexport const IDENTITY_SEPARATOR = '\\u0000'\n\n/** Stable stringify: object keys sorted, undefined-valued keys dropped, so equal inputs encode equally. */\nexport const stableStringify = (value: unknown): string => {\n  if (value === undefined) return 'null'\n  if (value === null || typeof value !== 'object') return JSON.stringify(value)\n  if (Array.isArray(value)) return `[${value.map(stableStringify).join(',')}]`\n  const record = value as Record<string, unknown>\n  return `{${Object.keys(record)\n    .filter(key => record[key] !== undefined)\n    .sort()\n    .map(key => `${JSON.stringify(key)}:${stableStringify(record[key])}`)\n    .join(',')}}`\n}\n\n/**\n * A connection's identity: the query's name and its input, encoded and\n * canonical. What the client keys a list by, and what a server that runs a\n * query from its request (a live list) names the list as.\n */\nexport const queryIdentity = (query: string, encodedInput: unknown): string =>\n  `${query}${IDENTITY_SEPARATOR}${stableStringify(encodedInput)}`\n\n/**\n * `Result: Project` (or anything with the entity's `name`, as `Query.connection`\n * takes) means a connection over it; a `ConnectionSpec` names its `entity`\n * instead and is the result as given.\n */\nexport type ResultOf<Result> = Result extends { readonly name: infer Entity extends string }\n  ? ConnectionSpec<Entity>\n  : Result\n\nconst isEntityName = (result: unknown): result is { readonly name: string } =>\n  typeof result === 'object' &&\n  result !== null &&\n  typeof (result as { readonly name?: unknown }).name === 'string'\n\n/**\n * The relational half comes from `foldkit-entity`, so one `Query` namespace\n * holds both what a query means (`from`, `where`, `orderBy`) and how this\n * client addresses it (`make`, `connection`, the window steps). They are one\n * vocabulary in use — a definition's body is composed and then named — and two\n * namespaces of the same name in one file would be a trap.\n */\n/**\n * One placeholder per key of the input's schema, each carrying that key's own\n * codec so a comparison against it is checked.\n *\n * A codec that is not a `Schema.Struct` exposes no keys to stand for, while its\n * *type* may well have them — so the body would be handed an empty object,\n * `input.slug` would be `undefined`, and the comparison would silently be\n * against nothing while the types all agreed. That is a wrong query rather than\n * a missing one, so it is refused where the query is declared.\n */\nconst inputsOf = (\n  name: string,\n  schema: Schema.Codec<unknown>,\n): Record<string, InputExpr<unknown>> => {\n  const fields = (schema as { readonly fields?: Schema.Struct.Fields }).fields\n  if (fields === undefined) {\n    throw new Error(\n      `[foldkit-remote] Query.define: the Input of \"${name}\" is not a Schema.Struct, so its body has no inputs to read. Declare it as fields (\\`{ slug: Schema.String }\\`) or a plain \\`Schema.Struct\\`.`,\n    )\n  }\n  const inputs: Record<string, InputExpr<unknown>> = {}\n  for (const key of Object.keys(fields)) {\n    inputs[key] = Expr.input(key, fields[key] as unknown as Schema.Codec<unknown, unknown>)\n  }\n  return Object.freeze(inputs)\n}\n\n/** A relational `Query` over one Entity, as `Query.define`'s body returns. */\ntype RelationalQueryOf<E extends AnyEntity> = ReturnType<typeof RelationalQuery.from<E>>\n\nexport const Query = {\n  ...RelationalQuery,\n\n  /** Declares the entity and options a query's result is a connection over. */\n  connection: <Entity extends string>(\n    entity: { readonly name: Entity },\n    options?: { readonly edgeKey?: Schema.Schema<unknown>; readonly live?: LivePolicy },\n  ): ConnectionSpec<Entity> => ({\n    entity: entity.name,\n    ...(options?.edgeKey === undefined ? {} : { edgeKey: options.edgeKey }),\n    ...(options?.live === undefined ? {} : { live: options.live }),\n  }),\n\n  /**\n   * Declares a query. `Input` is a codec or the fields of the `Schema.Struct` it\n   * would be; `Result` is a `Query.connection(...)`, or the entity the result is\n   * a connection over.\n   */\n  make: <const Name extends string, Input extends SchemaOrFields, Result>(\n    name: Name,\n    config: { readonly Input: Input; readonly Result: Result },\n  ): QueryDescriptor<Name, TypeOf<Input>, ResultOf<Result>> => {\n    const Input = schemaOf(config.Input)\n    const encode = Schema.encodeSync(Input)\n    return {\n      name,\n      Input,\n      Result: (isEntityName(config.Result)\n        ? Query.connection(config.Result)\n        : config.Result) as ResultOf<Result>,\n      ref: input => ({\n        query: name,\n        input,\n        Input,\n        window: {},\n        identity: queryIdentity(name, encode(input)),\n      }),\n    }\n  },\n\n  /**\n   * Declares a query by what it means. The body is built once, here, and the\n   * `input` it is given holds placeholders rather than values — there is\n   * nothing yet to branch on, so a condition that depends on what was passed is\n   * a comparison over the placeholder:\n   *\n   * ```ts\n   * const PostsBySlug = Query.define('PostsBySlug', { slug: Schema.String }, ({ input }) =>\n   *   Query.from(Post).pipe(\n   *     Query.where(Expr.eq(Post.fields.slug, input.slug)),\n   *     Query.orderBy(Order.asc(Post.fields.id)),\n   *   ),\n   * )\n   * ```\n   *\n   * What comes back is an ordinary `QueryDescriptor` — the same name, `Input`,\n   * `ref` and connection identity `Query.make` gives — carrying its `body`\n   * besides. A server can compile that body instead of being told the same\n   * thing again in its own dialect, and one that would rather answer the query\n   * its own way still can.\n   *\n   * The result is a connection over the Entity the body reads, so it is not\n   * named twice.\n   */\n  define: <const Name extends string, Input extends SchemaOrFields, E extends AnyEntity>(\n    name: Name,\n    Input: Input,\n    body: (context: { readonly input: QueryInputs<TypeOf<Input>> }) => RelationalQueryOf<E>,\n    options?: { readonly edgeKey?: Schema.Schema<unknown>; readonly live?: LivePolicy },\n  ): QueryDescriptor<Name, TypeOf<Input>, ConnectionSpec<E['name']>> => {\n    const schema = schemaOf(Input)\n    const built = body({ input: inputsOf(name, schema) as QueryInputs<TypeOf<Input>> })\n    const descriptor = Query.make(name, {\n      Input,\n      Result: Query.connection(built.entity, options) as ConnectionSpec<E['name']>,\n    })\n    return { ...descriptor, body: built }\n  },\n\n  first:\n    (count: number) =>\n    <R extends QueryRef<string, unknown>>(ref: R): R => ({\n      ...ref,\n      window: { ...ref.window, first: count },\n    }),\n\n  last:\n    (count: number) =>\n    <R extends QueryRef<string, unknown>>(ref: R): R => ({\n      ...ref,\n      window: { ...ref.window, last: count },\n    }),\n\n  after:\n    (cursor: Cursor) =>\n    <R extends QueryRef<string, unknown>>(ref: R): R => ({\n      ...ref,\n      window: { ...ref.window, after: cursor },\n    }),\n\n  before:\n    (cursor: Cursor) =>\n    <R extends QueryRef<string, unknown>>(ref: R): R => ({\n      ...ref,\n      window: { ...ref.window, before: cursor },\n    }),\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA8EA,MAAa,qBAAqB;;AAGlC,MAAa,mBAAmB,UAA2B;CACzD,IAAI,UAAU,KAAA,GAAW,OAAO;CAChC,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO,KAAK,UAAU,KAAK;CAC5E,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,IAAI,MAAM,IAAI,eAAe,CAAC,CAAC,KAAK,GAAG,EAAE;CAC1E,MAAM,SAAS;CACf,OAAO,IAAI,OAAO,KAAK,MAAM,CAAC,CAC3B,QAAO,QAAO,OAAO,SAAS,KAAA,CAAS,CAAC,CACxC,KAAK,CAAC,CACN,KAAI,QAAO,GAAG,KAAK,UAAU,GAAG,EAAE,GAAG,gBAAgB,OAAO,IAAI,GAAG,CAAC,CACpE,KAAK,GAAG,EAAE;AACf;;;;;;AAOA,MAAa,iBAAiB,OAAe,iBAC3C,GAAG,SAA6B,gBAAgB,YAAY;AAW9D,MAAM,gBAAgB,WACpB,OAAO,WAAW,YAClB,WAAW,QACX,OAAQ,OAAuC,SAAS;;;;;;;;;;;;;;;;;;AAmB1D,MAAM,YACJ,MACA,WACuC;CACvC,MAAM,SAAU,OAAsD;CACtE,IAAI,WAAW,KAAA,GACb,MAAM,IAAI,MACR,gDAAgD,KAAK,8IACvD;CAEF,MAAM,SAA6C,CAAC;CACpD,KAAK,MAAM,OAAO,OAAO,KAAK,MAAM,GAClC,OAAO,OAAO,KAAK,MAAM,KAAK,OAAO,IAAiD;CAExF,OAAO,OAAO,OAAO,MAAM;AAC7B;AAKA,MAAa,QAAQ;CACnB,GAAGA;;CAGH,aACE,QACA,aAC4B;EAC5B,QAAQ,OAAO;EACf,GAAI,SAAS,YAAY,KAAA,IAAY,CAAC,IAAI,EAAE,SAAS,QAAQ,QAAQ;EACrE,GAAI,SAAS,SAAS,KAAA,IAAY,CAAC,IAAI,EAAE,MAAM,QAAQ,KAAK;CAC9D;;;;;;CAOA,OACE,MACA,WAC2D;EAC3D,MAAM,QAAQ,SAAS,OAAO,KAAK;EACnC,MAAM,SAAS,OAAO,WAAW,KAAK;EACtC,OAAO;GACL;GACA;GACA,QAAS,aAAa,OAAO,MAAM,IAC/B,MAAM,WAAW,OAAO,MAAM,IAC9B,OAAO;GACX,MAAK,WAAU;IACb,OAAO;IACP;IACA;IACA,QAAQ,CAAC;IACT,UAAU,cAAc,MAAM,OAAO,KAAK,CAAC;GAC7C;EACF;CACF;;;;;;;;;;;;;;;;;;;;;;;;;CA0BA,SACE,MACA,OACA,MACA,YACoE;EACpE,MAAM,SAAS,SAAS,KAAK;EAC7B,MAAM,QAAQ,KAAK,EAAE,OAAO,SAAS,MAAM,MAAM,EAAgC,CAAC;EAKlF,OAAO;GAAE,GAJU,MAAM,KAAK,MAAM;IAClC;IACA,QAAQ,MAAM,WAAW,MAAM,QAAQ,OAAO;GAChD,CACqB;GAAG,MAAM;EAAM;CACtC;CAEA,QACG,WACqC,SAAe;EACnD,GAAG;EACH,QAAQ;GAAE,GAAG,IAAI;GAAQ,OAAO;EAAM;CACxC;CAEF,OACG,WACqC,SAAe;EACnD,GAAG;EACH,QAAQ;GAAE,GAAG,IAAI;GAAQ,MAAM;EAAM;CACvC;CAEF,QACG,YACqC,SAAe;EACnD,GAAG;EACH,QAAQ;GAAE,GAAG,IAAI;GAAQ,OAAO;EAAO;CACzC;CAEF,SACG,YACqC,SAAe;EACnD,GAAG;EACH,QAAQ;GAAE,GAAG,IAAI;GAAQ,QAAQ;EAAO;CAC1C;AACJ"}

package/dist/record.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Records keyed by a field name, which an application declares and the wire
+ * repeats. Read as `record[key]`, `constructor` or `toString` finds
+ * `Object.prototype`'s; written as `record[key] = value`, `__proto__` sets the
+ * prototype and adds no key.
+ */
+/** The value `record` holds under `key` itself, never one it inherits. */
+export declare const own: <A>(record: Readonly<Record<string, A>> | undefined, key: string) => A | undefined;
+/** Sets `key` on `record` as a key of its own, whatever the name. */
+export declare const put: <A>(record: Record<string, A>, key: string, value: A) => void;
+//# sourceMappingURL=record.d.ts.map

package/dist/record.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.d.ts","names":[],"sources":["../src/record.ts"],"mappings":";;;;;;;qBAQa,MAAO,GAAC,QACX,SAAS,eAAe,iBAAe,gBAE9C;;qBAGU,MAAO,GAAC,QAAU,eAAe,IAAE,aAAa,OAAS"}

package/dist/record.js

@@ -0,0 +1,21 @@
+// src/record.ts
+/**
+* Records keyed by a field name, which an application declares and the wire
+* repeats. Read as `record[key]`, `constructor` or `toString` finds
+* `Object.prototype`'s; written as `record[key] = value`, `__proto__` sets the
+* prototype and adds no key.
+*/
+/** The value `record` holds under `key` itself, never one it inherits. */
+const own = (record, key) => record !== void 0 && Object.hasOwn(record, key) ? record[key] : void 0;
+/** Sets `key` on `record` as a key of its own, whatever the name. */
+const put = (record, key, value) => {
+	Object.defineProperty(record, key, {
+		value,
+		writable: true,
+		enumerable: true,
+		configurable: true
+	});
+};
+export { own, put };
+
+//# sourceMappingURL=record.js.map

package/dist/record.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"record.js","names":[],"sources":["../src/record.ts"],"sourcesContent":["/**\n * Records keyed by a field name, which an application declares and the wire\n * repeats. Read as `record[key]`, `constructor` or `toString` finds\n * `Object.prototype`'s; written as `record[key] = value`, `__proto__` sets the\n * prototype and adds no key.\n */\n\n/** The value `record` holds under `key` itself, never one it inherits. */\nexport const own = <A>(\n  record: Readonly<Record<string, A>> | undefined,\n  key: string,\n): A | undefined => (record !== undefined && Object.hasOwn(record, key) ? record[key] : undefined)\n\n/** Sets `key` on `record` as a key of its own, whatever the name. */\nexport const put = <A>(record: Record<string, A>, key: string, value: A): void => {\n  Object.defineProperty(record, key, {\n    value,\n    writable: true,\n    enumerable: true,\n    configurable: true,\n  })\n}\n"],"mappings":";;;;;;;;AAQA,MAAa,OACX,QACA,QACmB,WAAW,KAAA,KAAa,OAAO,OAAO,QAAQ,GAAG,IAAI,OAAO,OAAO,KAAA;;AAGxF,MAAa,OAAU,QAA2B,KAAa,UAAmB;CAChF,OAAO,eAAe,QAAQ,KAAK;EACjC;EACA,UAAU;EACV,YAAY;EACZ,cAAc;CAChB,CAAC;AACH"}

package/dist/relation-BLBGOZom.d.ts

@@ -0,0 +1,59 @@
+import { n as RelationRequirement } from "./requirement-D57S2LpH.js";
+import { Schema } from "effect";
+interface RefParts {
+  readonly entity: string;
+  readonly id: string;
+}
+/** A page of refs as the wire and the store hold it. */
+interface RefPageValue {
+  readonly refs: ReadonlyArray<string>;
+  readonly hasNext: boolean;
+  readonly hasPrevious: boolean;
+}
+/** Marks the codec `Entity.ref`/`Entity.refPage` produce, so a Selection can tell the field's shape. */
+declare const RelationAnnotation = "foldkitRemoteRelation";
+/** The target entity's name on the same codec, so a nested selection of another entity is refused. */
+declare const RelationEntityAnnotation = "foldkitRemoteRelationEntity";
+type RelationKind = 'one' | 'many' | 'page';
+interface RelationShape {
+  readonly kind: RelationKind;
+  readonly nullable: boolean;
+  readonly entity: string;
+}
+/**
+ * A page of a relation that is a whole list is read under a name of its own, the
+ * field's name and the page's size: `comments@first=10`. It is a field like any
+ * other to the store, the planner, and the wire, so the whole list and a page of
+ * it are held side by side, merged, marked stale, and persisted each on its own.
+ * The server reads the name apart, reads the relation with the window, and
+ * answers under the alias. A cursor is not part of the name: a page read from a
+ * cursor merges onto the page it continues.
+ */
+declare const RELATION_ALIAS = "@";
+/** The alias a relation field is read under, for a window of this size. */
+declare const relationAlias: (field: string, window: {
+  readonly first?: number | undefined;
+  readonly last?: number | undefined;
+  readonly after?: string | undefined;
+  readonly before?: string | undefined;
+}) => string;
+/** The field an alias reads; a name that is no alias is its own field. */
+declare const aliasedField: (name: string) => string;
+/** Splits a ref key (`"Entity:id"`, the store key too) back into its parts. */
+declare const refParts: (encoded: string) => RefParts;
+/**
+ * The refs a relation value carries, in order. Anything that is not a ref key,
+ * an array of them, or a page of them contributes nothing.
+ */
+declare const refsIn: (value: unknown) => ReadonlyArray<RefParts>;
+/** The refs in a relation value that name the relation's target entity, and no other. */
+declare const targetsOf: (value: unknown, relation: RelationRequirement) => ReadonlyArray<RefParts>;
+declare const isRefPage: (value: unknown) => value is RefPageValue;
+/**
+ * The relation shape an entity field schema declares: a ref (`one`), a nullable
+ * ref, an array of refs (`many`), or a page of refs (`page`). `undefined` for a
+ * scalar field, which cannot take a nested selection.
+ */
+declare const relationShape: (schema: Schema.Constraint) => RelationShape | undefined;
+export { RelationEntityAnnotation as a, aliasedField as c, refsIn as d, relationAlias as f, RelationAnnotation as i, isRefPage as l, targetsOf as m, RefPageValue as n, RelationKind as o, relationShape as p, RefParts as r, RelationShape as s, RELATION_ALIAS as t, refParts as u };
+//# sourceMappingURL=relation-BLBGOZom.d.ts.map

package/dist/relation-BLBGOZom.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation-BLBGOZom.d.ts","names":[],"sources":["../src/relation.ts"],"mappings":";;UASiB;WACN;WACA;;;UAIM;WACN,MAAM;WACN;WACA;;;cAIE;;cAEA;KAED;UAEK;WACN,MAAM;WACN;WACA;;;;;;;;;;;cAYE;;cAGA,gBAAa,eACX;WAEF;WACA;WAEA;WACA;;;cAMA,eAAY;;cAMZ,WAAQ,oBAAsB;;;;;cAW9B,SAAM,mBAAqB,cAAc;;cAWzC,YAAS,gBAAkB,UAAY,wBAAsB,cAAc;cAG3E,YAAS,mBAAqB,SAAS;;;;;;cAgBvC,gBAAa,QAAY,OAAO,eAAa"}

package/dist/relation.d.ts

@@ -0,0 +1,2 @@
+import { a as RelationEntityAnnotation, c as aliasedField, d as refsIn, f as relationAlias, i as RelationAnnotation, l as isRefPage, m as targetsOf, n as RefPageValue, o as RelationKind, p as relationShape, r as RefParts, s as RelationShape, t as RELATION_ALIAS, u as refParts } from "./relation-BLBGOZom.js";
+export { RELATION_ALIAS, RefPageValue, RefParts, RelationAnnotation, RelationEntityAnnotation, RelationKind, RelationShape, aliasedField, isRefPage, refParts, refsIn, relationAlias, relationShape, targetsOf };

package/dist/relation.js

@@ -0,0 +1,93 @@
+import { SchemaAST } from "effect";
+import { SchemaShape } from "foldkit-entity";
+// src/relation.ts
+/**
+* Relation values on the wire and in the store: a ref key (`"Entity:id"`), a
+* nullable ref key, an array of ref keys, or a page of ref keys. The planner
+* follows them into the store; the server follows them into the next read.
+*/
+/** Marks the codec `Entity.ref`/`Entity.refPage` produce, so a Selection can tell the field's shape. */
+const RelationAnnotation = "foldkitRemoteRelation";
+/** The target entity's name on the same codec, so a nested selection of another entity is refused. */
+const RelationEntityAnnotation = "foldkitRemoteRelationEntity";
+/**
+* A page of a relation that is a whole list is read under a name of its own, the
+* field's name and the page's size: `comments@first=10`. It is a field like any
+* other to the store, the planner, and the wire, so the whole list and a page of
+* it are held side by side, merged, marked stale, and persisted each on its own.
+* The server reads the name apart, reads the relation with the window, and
+* answers under the alias. A cursor is not part of the name: a page read from a
+* cursor merges onto the page it continues.
+*/
+const RELATION_ALIAS = "@";
+/** The alias a relation field is read under, for a window of this size. */
+const relationAlias = (field, window) => `${field}@${window.last !== void 0 ? `last=${window.last}` : `first=${window.first ?? ""}`}`;
+/** The field an alias reads; a name that is no alias is its own field. */
+const aliasedField = (name) => {
+	const at = name.indexOf("@");
+	return at === -1 ? name : name.slice(0, at);
+};
+/** Splits a ref key (`"Entity:id"`, the store key too) back into its parts. */
+const refParts = (encoded) => {
+	const separator = encoded.indexOf(":");
+	return separator === -1 ? {
+		entity: encoded,
+		id: ""
+	} : {
+		entity: encoded.slice(0, separator),
+		id: encoded.slice(separator + 1)
+	};
+};
+/**
+* The refs a relation value carries, in order. Anything that is not a ref key,
+* an array of them, or a page of them contributes nothing.
+*/
+const refsIn = (value) => {
+	if (typeof value === "string") return [refParts(value)];
+	if (Array.isArray(value)) return value.filter((item) => typeof item === "string").map(refParts);
+	if (value !== null && typeof value === "object") {
+		const refs = value.refs;
+		if (Array.isArray(refs)) return refs.filter((item) => typeof item === "string").map(refParts);
+	}
+	return [];
+};
+/** The refs in a relation value that name the relation's target entity, and no other. */
+const targetsOf = (value, relation) => refsIn(value).filter((ref) => ref.entity === relation.entity);
+const isRefPage = (value) => {
+	if (value === null || typeof value !== "object") return false;
+	const page = value;
+	return Array.isArray(page.refs) && page.refs.every((ref) => typeof ref === "string") && typeof page.hasNext === "boolean" && typeof page.hasPrevious === "boolean";
+};
+/**
+* The relation shape an entity field schema declares: a ref (`one`), a nullable
+* ref, an array of refs (`many`), or a page of refs (`page`). `undefined` for a
+* scalar field, which cannot take a nested selection.
+*/
+const relationShape = (schema) => shapeOf(schema.ast, false);
+const shapeOf = (ast, nullable) => {
+	const annotated = ast.annotations?.[RelationAnnotation];
+	if (annotated === "one" || annotated === "page") return {
+		kind: annotated,
+		nullable,
+		entity: String(ast.annotations?.[RelationEntityAnnotation])
+	};
+	if (SchemaAST.isArrays(ast)) {
+		const item = ast.rest[0];
+		const inner = item === void 0 ? void 0 : shapeOf(item, false);
+		return inner?.kind === "one" ? {
+			kind: "many",
+			nullable,
+			entity: inner.entity
+		} : void 0;
+	}
+	if (SchemaAST.isUnion(ast)) {
+		const optional = ast.types.some(SchemaShape.isNullish);
+		for (const member of ast.types) {
+			const shape = shapeOf(member, optional);
+			if (shape !== void 0) return shape;
+		}
+	}
+};
+export { RELATION_ALIAS, RelationAnnotation, RelationEntityAnnotation, aliasedField, isRefPage, refParts, refsIn, relationAlias, relationShape, targetsOf };
+
+//# sourceMappingURL=relation.js.map

package/dist/relation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"relation.js","names":[],"sources":["../src/relation.ts"],"sourcesContent":["/**\n * Relation values on the wire and in the store: a ref key (`\"Entity:id\"`), a\n * nullable ref key, an array of ref keys, or a page of ref keys. The planner\n * follows them into the store; the server follows them into the next read.\n */\nimport { SchemaAST, type Schema } from 'effect'\nimport { SchemaShape } from 'foldkit-entity'\nimport type { RelationRequirement } from './requirement.js'\n\nexport interface RefParts {\n  readonly entity: string\n  readonly id: string\n}\n\n/** A page of refs as the wire and the store hold it. */\nexport interface RefPageValue {\n  readonly refs: ReadonlyArray<string>\n  readonly hasNext: boolean\n  readonly hasPrevious: boolean\n}\n\n/** Marks the codec `Entity.ref`/`Entity.refPage` produce, so a Selection can tell the field's shape. */\nexport const RelationAnnotation = 'foldkitRemoteRelation'\n/** The target entity's name on the same codec, so a nested selection of another entity is refused. */\nexport const RelationEntityAnnotation = 'foldkitRemoteRelationEntity'\n\nexport type RelationKind = 'one' | 'many' | 'page'\n\nexport interface RelationShape {\n  readonly kind: RelationKind\n  readonly nullable: boolean\n  readonly entity: string\n}\n\n/**\n * A page of a relation that is a whole list is read under a name of its own, the\n * field's name and the page's size: `comments@first=10`. It is a field like any\n * other to the store, the planner, and the wire, so the whole list and a page of\n * it are held side by side, merged, marked stale, and persisted each on its own.\n * The server reads the name apart, reads the relation with the window, and\n * answers under the alias. A cursor is not part of the name: a page read from a\n * cursor merges onto the page it continues.\n */\nexport const RELATION_ALIAS = '@'\n\n/** The alias a relation field is read under, for a window of this size. */\nexport const relationAlias = (\n  field: string,\n  window: {\n    readonly first?: number | undefined\n    readonly last?: number | undefined\n    // A cursor is no part of the name: a page read from one merges onto the page it continues.\n    readonly after?: string | undefined\n    readonly before?: string | undefined\n  },\n): string =>\n  `${field}${RELATION_ALIAS}${window.last !== undefined ? `last=${window.last}` : `first=${window.first ?? ''}`}`\n\n/** The field an alias reads; a name that is no alias is its own field. */\nexport const aliasedField = (name: string): string => {\n  const at = name.indexOf(RELATION_ALIAS)\n  return at === -1 ? name : name.slice(0, at)\n}\n\n/** Splits a ref key (`\"Entity:id\"`, the store key too) back into its parts. */\nexport const refParts = (encoded: string): RefParts => {\n  const separator = encoded.indexOf(':')\n  return separator === -1\n    ? { entity: encoded, id: '' }\n    : { entity: encoded.slice(0, separator), id: encoded.slice(separator + 1) }\n}\n\n/**\n * The refs a relation value carries, in order. Anything that is not a ref key,\n * an array of them, or a page of them contributes nothing.\n */\nexport const refsIn = (value: unknown): ReadonlyArray<RefParts> => {\n  if (typeof value === 'string') return [refParts(value)]\n  if (Array.isArray(value)) return value.filter(item => typeof item === 'string').map(refParts)\n  if (value !== null && typeof value === 'object') {\n    const refs = (value as { readonly refs?: unknown }).refs\n    if (Array.isArray(refs)) return refs.filter(item => typeof item === 'string').map(refParts)\n  }\n  return []\n}\n\n/** The refs in a relation value that name the relation's target entity, and no other. */\nexport const targetsOf = (value: unknown, relation: RelationRequirement): ReadonlyArray<RefParts> =>\n  refsIn(value).filter(ref => ref.entity === relation.entity)\n\nexport const isRefPage = (value: unknown): value is RefPageValue => {\n  if (value === null || typeof value !== 'object') return false\n  const page = value as Record<string, unknown>\n  return (\n    Array.isArray(page.refs) &&\n    page.refs.every(ref => typeof ref === 'string') &&\n    typeof page.hasNext === 'boolean' &&\n    typeof page.hasPrevious === 'boolean'\n  )\n}\n\n/**\n * The relation shape an entity field schema declares: a ref (`one`), a nullable\n * ref, an array of refs (`many`), or a page of refs (`page`). `undefined` for a\n * scalar field, which cannot take a nested selection.\n */\nexport const relationShape = (schema: Schema.Constraint): RelationShape | undefined =>\n  shapeOf(schema.ast, false)\n\nconst shapeOf = (ast: SchemaAST.AST, nullable: boolean): RelationShape | undefined => {\n  const annotated = ast.annotations?.[RelationAnnotation]\n  if (annotated === 'one' || annotated === 'page') {\n    return {\n      kind: annotated,\n      nullable,\n      entity: String(ast.annotations?.[RelationEntityAnnotation]),\n    }\n  }\n  if (SchemaAST.isArrays(ast)) {\n    const item = ast.rest[0]\n    const inner = item === undefined ? undefined : shapeOf(item, false)\n    return inner?.kind === 'one' ? { kind: 'many', nullable, entity: inner.entity } : undefined\n  }\n  if (SchemaAST.isUnion(ast)) {\n    const optional = ast.types.some(SchemaShape.isNullish)\n    for (const member of ast.types) {\n      const shape = shapeOf(member, optional)\n      if (shape !== undefined) return shape\n    }\n  }\n  return undefined\n}\n"],"mappings":";;;;;;;;;AAsBA,MAAa,qBAAqB;;AAElC,MAAa,2BAA2B;;;;;;;;;;AAmBxC,MAAa,iBAAiB;;AAG9B,MAAa,iBACX,OACA,WAQA,GAAG,SAAyB,OAAO,SAAS,KAAA,IAAY,QAAQ,OAAO,SAAS,SAAS,OAAO,SAAS;;AAG3G,MAAa,gBAAgB,SAAyB;CACpD,MAAM,KAAK,KAAK,QAAA,GAAsB;CACtC,OAAO,OAAO,KAAK,OAAO,KAAK,MAAM,GAAG,EAAE;AAC5C;;AAGA,MAAa,YAAY,YAA8B;CACrD,MAAM,YAAY,QAAQ,QAAQ,GAAG;CACrC,OAAO,cAAc,KACjB;EAAE,QAAQ;EAAS,IAAI;CAAG,IAC1B;EAAE,QAAQ,QAAQ,MAAM,GAAG,SAAS;EAAG,IAAI,QAAQ,MAAM,YAAY,CAAC;CAAE;AAC9E;;;;;AAMA,MAAa,UAAU,UAA4C;CACjE,IAAI,OAAO,UAAU,UAAU,OAAO,CAAC,SAAS,KAAK,CAAC;CACtD,IAAI,MAAM,QAAQ,KAAK,GAAG,OAAO,MAAM,QAAO,SAAQ,OAAO,SAAS,QAAQ,CAAC,CAAC,IAAI,QAAQ;CAC5F,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU;EAC/C,MAAM,OAAQ,MAAsC;EACpD,IAAI,MAAM,QAAQ,IAAI,GAAG,OAAO,KAAK,QAAO,SAAQ,OAAO,SAAS,QAAQ,CAAC,CAAC,IAAI,QAAQ;CAC5F;CACA,OAAO,CAAC;AACV;;AAGA,MAAa,aAAa,OAAgB,aACxC,OAAO,KAAK,CAAC,CAAC,QAAO,QAAO,IAAI,WAAW,SAAS,MAAM;AAE5D,MAAa,aAAa,UAA0C;CAClE,IAAI,UAAU,QAAQ,OAAO,UAAU,UAAU,OAAO;CACxD,MAAM,OAAO;CACb,OACE,MAAM,QAAQ,KAAK,IAAI,KACvB,KAAK,KAAK,OAAM,QAAO,OAAO,QAAQ,QAAQ,KAC9C,OAAO,KAAK,YAAY,aACxB,OAAO,KAAK,gBAAgB;AAEhC;;;;;;AAOA,MAAa,iBAAiB,WAC5B,QAAQ,OAAO,KAAK,KAAK;AAE3B,MAAM,WAAW,KAAoB,aAAiD;CACpF,MAAM,YAAY,IAAI,cAAc;CACpC,IAAI,cAAc,SAAS,cAAc,QACvC,OAAO;EACL,MAAM;EACN;EACA,QAAQ,OAAO,IAAI,cAAc,yBAAyB;CAC5D;CAEF,IAAI,UAAU,SAAS,GAAG,GAAG;EAC3B,MAAM,OAAO,IAAI,KAAK;EACtB,MAAM,QAAQ,SAAS,KAAA,IAAY,KAAA,IAAY,QAAQ,MAAM,KAAK;EAClE,OAAO,OAAO,SAAS,QAAQ;GAAE,MAAM;GAAQ;GAAU,QAAQ,MAAM;EAAO,IAAI,KAAA;CACpF;CACA,IAAI,UAAU,QAAQ,GAAG,GAAG;EAC1B,MAAM,WAAW,IAAI,MAAM,KAAK,YAAY,SAAS;EACrD,KAAK,MAAM,UAAU,IAAI,OAAO;GAC9B,MAAM,QAAQ,QAAQ,QAAQ,QAAQ;GACtC,IAAI,UAAU,KAAA,GAAW,OAAO;EAClC;CACF;AAEF"}