@shivaedev/contract 0.51.0 → 0.53.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (66) hide show
  1. package/CHANGELOG.md +16 -0
  2. package/README.md +14 -1
  3. package/dist/QueryStorage.d.ts +18 -0
  4. package/dist/QueryStorage.d.ts.map +1 -0
  5. package/dist/QueryStorage.js +4 -0
  6. package/dist/QueryStorage.js.map +1 -0
  7. package/dist/adapters/activityState.d.ts +1 -0
  8. package/dist/adapters/activityState.d.ts.map +1 -1
  9. package/dist/adapters/activityState.js +7 -1
  10. package/dist/adapters/activityState.js.map +1 -1
  11. package/dist/adapters/browserQueryStorage.d.ts +4 -0
  12. package/dist/adapters/browserQueryStorage.d.ts.map +1 -0
  13. package/dist/adapters/browserQueryStorage.js +12 -0
  14. package/dist/adapters/browserQueryStorage.js.map +1 -0
  15. package/dist/adapters/indexedQueryRows.d.ts +13 -0
  16. package/dist/adapters/indexedQueryRows.d.ts.map +1 -0
  17. package/dist/adapters/indexedQueryRows.js +53 -0
  18. package/dist/adapters/indexedQueryRows.js.map +1 -0
  19. package/dist/adapters/queryPersistence.d.ts +11 -0
  20. package/dist/adapters/queryPersistence.d.ts.map +1 -0
  21. package/dist/adapters/queryPersistence.js +124 -0
  22. package/dist/adapters/queryPersistence.js.map +1 -0
  23. package/dist/adapters/storedQueryAccess.d.ts +16 -0
  24. package/dist/adapters/storedQueryAccess.d.ts.map +1 -0
  25. package/dist/adapters/storedQueryAccess.js +30 -0
  26. package/dist/adapters/storedQueryAccess.js.map +1 -0
  27. package/dist/clientActivities.d.ts +2 -2
  28. package/dist/clientActivities.d.ts.map +1 -1
  29. package/dist/clientActivities.js +11 -6
  30. package/dist/clientActivities.js.map +1 -1
  31. package/dist/clientOperations.d.ts.map +1 -1
  32. package/dist/clientOperations.js +9 -4
  33. package/dist/clientOperations.js.map +1 -1
  34. package/dist/queryRetention.d.ts +1 -0
  35. package/dist/queryRetention.d.ts.map +1 -1
  36. package/dist/queryRetention.js.map +1 -1
  37. package/dist/retainQuery.d.ts +2 -1
  38. package/dist/retainQuery.d.ts.map +1 -1
  39. package/dist/retainQuery.js +20 -2
  40. package/dist/retainQuery.js.map +1 -1
  41. package/dist/storedQueries.d.ts +17 -0
  42. package/dist/storedQueries.d.ts.map +1 -0
  43. package/dist/storedQueries.js +17 -0
  44. package/dist/storedQueries.js.map +1 -0
  45. package/dist/subjectHeader.d.ts +1 -0
  46. package/dist/subjectHeader.d.ts.map +1 -1
  47. package/dist/subjectHeader.js +4 -1
  48. package/dist/subjectHeader.js.map +1 -1
  49. package/dist/warmQueries.d.ts +3 -0
  50. package/dist/warmQueries.d.ts.map +1 -0
  51. package/dist/warmQueries.js +4 -0
  52. package/dist/warmQueries.js.map +1 -0
  53. package/package.json +10 -9
  54. package/src/QueryStorage.ts +18 -0
  55. package/src/adapters/activityState.ts +7 -1
  56. package/src/adapters/browserQueryStorage.ts +14 -0
  57. package/src/adapters/indexedQueryRows.ts +66 -0
  58. package/src/adapters/queryPersistence.ts +134 -0
  59. package/src/adapters/storedQueryAccess.ts +37 -0
  60. package/src/clientActivities.ts +11 -6
  61. package/src/clientOperations.ts +9 -4
  62. package/src/queryRetention.ts +1 -0
  63. package/src/retainQuery.ts +25 -2
  64. package/src/storedQueries.ts +34 -0
  65. package/src/subjectHeader.ts +5 -1
  66. package/src/warmQueries.ts +5 -0
@@ -3,13 +3,14 @@ import * as AsyncResult from "effect/reactivity/AsyncResult";
3
3
  import type * as Atom from "effect/reactivity/Atom";
4
4
  import { activityState } from "#adapters/activityState.ts";
5
5
  import { clientConnection } from "#adapters/clientConnection.ts";
6
+ import { shareQuerySignals } from "#querySignals.ts";
6
7
  import { wrapAtom } from "#wrapAtom.ts";
7
8
 
8
9
  type ActivityTracker = ReturnType<typeof makeActivity>;
9
10
  export const clientActivities = new WeakMap<object, ActivityTracker>();
10
11
 
11
12
  export function makeActivity(factory: Atom.RuntimeFactory) {
12
- const { activity, answered, change, hold, setConnection } = activityState();
13
+ const { activity, answered, change, hold, setConnection, warming } = activityState();
13
14
  const connection = clientConnection(factory, setConnection, activity);
14
15
  function begin(key: "rpcCalls" | "commands" | "unreflectedCommands") {
15
16
  change(key, 1);
@@ -29,21 +30,22 @@ export function makeActivity(factory: Atom.RuntimeFactory) {
29
30
  (end) => Effect.sync(end),
30
31
  );
31
32
  }
32
- function counter(key: "initialQueries" | "refreshingAtoms") {
33
+ function counter(apply: (delta: number) => void) {
33
34
  let pending = false;
34
35
  function set(next: boolean) {
35
36
  if (pending !== next) {
36
37
  pending = next;
37
- change(key, next ? 1 : -1);
38
+ apply(next ? 1 : -1);
38
39
  }
39
40
  }
40
41
  return { release: () => set(false), set };
41
42
  }
42
- function watch<A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) {
43
+ function watch<A, E>(atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>, warm: (get: Atom.AtomContext) => boolean) {
43
44
  const watched = wrapAtom(atom, (get) => {
44
45
  get.mount(connection.status);
45
- const refreshing = counter("refreshingAtoms");
46
- const initial = counter("initialQueries");
46
+ const refreshing = counter((delta) => change("refreshingAtoms", delta));
47
+ const initial = counter((delta) => change("initialQueries", delta));
48
+ const warmInitial = counter(warming);
47
49
  let received = false;
48
50
  let active = true;
49
51
  let published = false;
@@ -54,6 +56,7 @@ export function makeActivity(factory: Atom.RuntimeFactory) {
54
56
  const first = !(received || AsyncResult.isInitial(result));
55
57
  received ||= first;
56
58
  initial.set(!received);
59
+ warmInitial.set(!received && warm(get));
57
60
  refreshing.set(result.waiting || AsyncResult.isInitial(result));
58
61
  if (first) {
59
62
  answered();
@@ -62,6 +65,7 @@ export function makeActivity(factory: Atom.RuntimeFactory) {
62
65
  get.addFinalizer(() => {
63
66
  active = false;
64
67
  refreshing.release();
68
+ warmInitial.release();
65
69
  initial.release();
66
70
  });
67
71
  function publish(result: AsyncResult.AsyncResult<A, E>) {
@@ -77,6 +81,7 @@ export function makeActivity(factory: Atom.RuntimeFactory) {
77
81
  }
78
82
  return value;
79
83
  });
84
+ shareQuerySignals(watched, atom);
80
85
  return watched;
81
86
  }
82
87
  return {
@@ -17,10 +17,11 @@ import { CommandSignal, untilReflected } from "#commandSignal.ts";
17
17
  import { waitForConnection } from "#connectionReadiness.ts";
18
18
  import { LIVE_SYNC } from "#liveSyncRpc.ts";
19
19
  import type { CommandShape, QueryShape } from "#operation.ts";
20
- import { shareQuerySignals } from "#querySignals.ts";
21
20
  import { type CommandObserver, reflectCommand } from "#reflectCommand.ts";
22
21
  import { retainQuery } from "#retainQuery.ts";
23
- import { subjectSerializationKey, withSubject } from "#subjectHeader.ts";
22
+ import { storedForm } from "#storedQueries.ts";
23
+ import { inputSubject, subjectSerializationKey, withSubject } from "#subjectHeader.ts";
24
+ import { warmQueries } from "#warmQueries.ts";
24
25
 
25
26
  // `runtime.fn(api.save.run)` passes its function context as the second argument, so only an options object selects a subject.
26
27
  function runSubject(options: unknown): string | undefined {
@@ -45,6 +46,7 @@ export function clientOperations(
45
46
 
46
47
  function boundQuery(tag: string, query: QueryShape) {
47
48
  const cached = new WeakMap<ReturnType<typeof ordinaryClient.query>, ReturnType<typeof ordinaryClient.query>>();
49
+ const stored = storedForm(tag, query);
48
50
  return {
49
51
  query: (payload: unknown, { headers: given, serializationKey, subject }: QueryOptions = {}) => {
50
52
  const headers = withSubject(given, subject);
@@ -71,8 +73,11 @@ export function clientOperations(
71
73
  (source) => ordinaryClient.runtime.factory.withReactivity(clientReadKeys(dependencies, owner?.context))(source),
72
74
  headers,
73
75
  );
74
- const tracked = retainQuery(ordinaryClient.runtime, clientActivities.get(ordinaryClient)?.watch(result) ?? result);
75
- shareQuerySignals(tracked, result);
76
+ function warm(get: Atom.AtomContext): boolean {
77
+ return get.once(warmQueries).has(tracked);
78
+ }
79
+ const watched = clientActivities.get(ordinaryClient)?.watch(result, warm) ?? result;
80
+ const tracked = retainQuery(ordinaryClient.runtime, watched, stored(payload, inputSubject(headers)));
76
81
  cached.set(atom, tracked);
77
82
  return tracked;
78
83
  },
@@ -3,6 +3,7 @@ import * as Atom from "effect/reactivity/Atom";
3
3
 
4
4
  export interface QueryRetentionOptions {
5
5
  readonly capacity?: number;
6
+ readonly storedBytes?: number;
6
7
  readonly timeToLive?: Duration.Input;
7
8
  }
8
9
 
@@ -1,8 +1,10 @@
1
- import { Option } from "effect";
1
+ import { Cause, Option, Predicate } from "effect";
2
2
  import * as AsyncResult from "effect/reactivity/AsyncResult";
3
3
  import * as Atom from "effect/reactivity/Atom";
4
+ import { queryPersistence } from "#adapters/queryPersistence.ts";
4
5
  import { retainedQueries } from "#adapters/retainedQueries.ts";
5
6
  import { querySignals, shareQuerySignals } from "#querySignals.ts";
7
+ import type { StoredForm } from "#storedQueries.ts";
6
8
  import { wrapAtom } from "#wrapAtom.ts";
7
9
 
8
10
  const runtimes = new WeakMap<Atom.Atom<unknown>, Atom.AtomRuntime<unknown, unknown>>();
@@ -11,22 +13,43 @@ export function queryRuntime(query: Atom.Atom<unknown>): Atom.AtomRuntime<unknow
11
13
  return runtimes.get(query);
12
14
  }
13
15
 
14
- export function retainQuery<A, E>(runtime: Atom.AtomRuntime<unknown, unknown>, atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>) {
16
+ const gone = Predicate.or(Predicate.isTagged("QueryReadDenied"), Predicate.isTagged("NotFound"));
17
+
18
+ export function retainQuery<A, E>(
19
+ runtime: Atom.AtomRuntime<unknown, unknown>,
20
+ atom: Atom.Atom<AsyncResult.AsyncResult<A, E>>,
21
+ stored?: StoredForm<A>,
22
+ ) {
15
23
  const snapshot = Atom.make<Option.Option<AsyncResult.Success<A, E>>>(Option.none()).pipe(Atom.setIdleTTL(0));
16
24
  const signals = querySignals(atom);
17
25
  const retained = wrapAtom(atom, (get) => {
18
26
  get.mount(snapshot);
19
27
  const owner = get.once(retainedQueries);
28
+ const persistence = stored === undefined ? undefined : get.once(queryPersistence);
20
29
  owner.take(retained);
21
30
  get.addFinalizer(() => {
22
31
  if (get.registry.getNodes().has(snapshot) && Option.isSome(get.registry.get(snapshot))) {
23
32
  owner.keep(retained, snapshot, runtime);
24
33
  }
25
34
  });
35
+ if (stored !== undefined && persistence !== undefined && Option.isNone(get.once(snapshot))) {
36
+ Option.map(persistence.restore(stored, runtime), (value) => get.set(snapshot, Option.some(AsyncResult.success<A, E>(value))));
37
+ }
38
+ function persist(result: AsyncResult.AsyncResult<A, E>) {
39
+ if (stored === undefined || persistence === undefined || result.waiting) {
40
+ return;
41
+ }
42
+ if (AsyncResult.isSuccess(result)) {
43
+ persistence.save(stored, result.value, runtime);
44
+ } else if (AsyncResult.isFailure(result) && Option.exists(Cause.findErrorOption(result.cause), gone)) {
45
+ persistence.drop(stored, runtime);
46
+ }
47
+ }
26
48
  function display(result: AsyncResult.AsyncResult<A, E>) {
27
49
  if (AsyncResult.isSuccess(result) && !result.waiting) {
28
50
  get.set(snapshot, Option.some(result));
29
51
  }
52
+ persist(result);
30
53
  const kept = AsyncResult.isInitial(result) ? get.once(snapshot) : Option.none<AsyncResult.Success<A, E>>();
31
54
  get.set(signals, { ...get.once(signals), retained: Option.isSome(kept) });
32
55
  return Option.match(kept, { onNone: () => result, onSome: AsyncResult.waiting });
@@ -0,0 +1,34 @@
1
+ import { Effect, Schema } from "effect";
2
+ import * as Atom from "effect/reactivity/Atom";
3
+ import type { QueryShape } from "#operation.ts";
4
+ import type { QueryStorage, StoredQuery } from "#QueryStorage.ts";
5
+
6
+ export interface OpenedQueryStorage {
7
+ readonly entries: readonly StoredQuery[];
8
+ readonly storage: QueryStorage;
9
+ readonly user: string;
10
+ }
11
+
12
+ // An operation's schemas may need services, so each step is an Effect that the query runtime's services run.
13
+ export interface StoredForm<A> {
14
+ readonly decode: (raw: string) => Effect.Effect<A, Schema.SchemaError, unknown>;
15
+ readonly encode: (value: A) => Effect.Effect<string, Schema.SchemaError, unknown>;
16
+ readonly key: Effect.Effect<string, Schema.SchemaError, unknown>;
17
+ }
18
+
19
+ export const storedQueries = Atom.keepAlive(Atom.make<OpenedQueryStorage | undefined>(undefined));
20
+
21
+ function jsonText<TSchema extends Schema.Top>(schema: TSchema) {
22
+ return Schema.fromJsonString(Schema.toCodecJson(schema));
23
+ }
24
+
25
+ export function storedForm(tag: string, query: QueryShape) {
26
+ const payload = Schema.encodeUnknownEffect(jsonText(query.payload));
27
+ const decode = Schema.decodeUnknownEffect(jsonText(query.success));
28
+ const encode = Schema.encodeUnknownEffect(jsonText(query.success));
29
+ return (value: unknown, subject: string | undefined): StoredForm<unknown> => ({
30
+ decode,
31
+ encode,
32
+ key: Effect.map(payload(value), (encoded) => JSON.stringify([tag, encoded, subject ?? null])),
33
+ });
34
+ }
@@ -10,8 +10,12 @@ export function withSubject(headers: Headers.Input | undefined, subject: string
10
10
  return subject === undefined ? headers : Headers.set(Headers.fromInput(headers), HEADER, subject);
11
11
  }
12
12
 
13
+ export function inputSubject(headers: Headers.Input | undefined): string | undefined {
14
+ return headers === undefined ? undefined : subjectHeader(Headers.fromInput(headers));
15
+ }
16
+
13
17
  // Effect keys a serialized query by its tag and this key alone, so a subject that the key leaves out would hydrate into another subject's query.
14
18
  export function subjectSerializationKey(key: string | undefined, headers: Headers.Input | undefined): string | undefined {
15
- const subject = headers === undefined ? undefined : subjectHeader(Headers.fromInput(headers));
19
+ const subject = inputSubject(headers);
16
20
  return key === undefined || subject === undefined ? key : `${key}:subject:${subject}`;
17
21
  }
@@ -0,0 +1,5 @@
1
+ import * as Atom from "effect/reactivity/Atom";
2
+
3
+ const none: ReadonlySet<Atom.Atom<unknown>> = new Set();
4
+
5
+ export const warmQueries = Atom.keepAlive(Atom.make(none));