@rocicorp/zero 0.0.0-202410031711

package/out/zero-protocol/src/poke.d.ts

@@ -0,0 +1,236 @@
+import * as v from '../../shared/src/valita.js';
+/**
+ * Pokes use a multi-part format. Pokes send entity data to the client and can
+ * be multiple mega-bytes in size. Using a multi-part format allows the server
+ * to avoid having to have the full poke in memory at one time.
+ *
+ * Each poke is assigned a `pokeID`, a unique id (within the context of the
+ * connection) for identifying the poke.  All messages for a poke will have the
+ * same `pokeID`.
+ *
+ * A poke begins with a `poke-start` message which contains the `baseCookie`
+ * the poke is updating from and the `cookie` the poke is updating to.
+ *
+ * The poke continues with zero to many `poke-part` messages, each of which
+ * can contain patch parts.  These patch parts should be merged in the order
+ * received.
+ *
+ * Finally, the poke ends with a `poke-end` message.  The merged `poke-parts`
+ * can now be applied as a whole to update from `baseCookie` to `cookie`.
+ *
+ * Poke messages can be intermingled with other `down` messages, but cannot be
+ * intermingled with poke messages for a different `pokeID`. If this is
+ * observed it is an unexpected error; the client should ignore both pokes,
+ * disconnect, and reconnect.
+ */
+export declare const pokeStartBodySchema: v.ObjectType<{
+    pokeID: v.Type<string>;
+    baseCookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
+    cookie: v.Type<string>;
+    timestamp: v.Optional<number>;
+}, undefined>;
+export declare const pokePartBodySchema: v.ObjectType<{
+    pokeID: v.Type<string>;
+    lastMutationIDChanges: v.Optional<Record<string, number>>;
+    clientsPatch: v.Optional<({
+        op: "put";
+        clientID: string;
+    } | {
+        op: "del";
+        clientID: string;
+    } | {
+        op: "clear";
+    })[]>;
+    desiredQueriesPatches: v.Optional<Record<string, ({
+        op: "put";
+        hash: string;
+        ast: {
+            schema?: string | undefined;
+            alias?: string | undefined;
+            where?: readonly {
+                type: "simple";
+                op: "=" | "!=" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+                field: string;
+                value: string | number | boolean | readonly (string | number | boolean)[] | {
+                    type: "static";
+                    anchor: "authData" | "preMutationRow";
+                    field: string;
+                };
+            }[] | undefined;
+            related?: readonly import("../../zql/src/zql/ast/ast.js").CorrelatedSubQuery[] | undefined;
+            limit?: number | undefined;
+            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
+            start?: {
+                row: Record<string, string | number | boolean | null | undefined>;
+                exclusive: boolean;
+            } | undefined;
+            table: string;
+        };
+    } | {
+        op: "del";
+        hash: string;
+    } | {
+        op: "clear";
+    })[]>>;
+    gotQueriesPatch: v.Optional<({
+        op: "put";
+        hash: string;
+        ast: {
+            schema?: string | undefined;
+            alias?: string | undefined;
+            where?: readonly {
+                type: "simple";
+                op: "=" | "!=" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+                field: string;
+                value: string | number | boolean | readonly (string | number | boolean)[] | {
+                    type: "static";
+                    anchor: "authData" | "preMutationRow";
+                    field: string;
+                };
+            }[] | undefined;
+            related?: readonly import("../../zql/src/zql/ast/ast.js").CorrelatedSubQuery[] | undefined;
+            limit?: number | undefined;
+            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
+            start?: {
+                row: Record<string, string | number | boolean | null | undefined>;
+                exclusive: boolean;
+            } | undefined;
+            table: string;
+        };
+    } | {
+        op: "del";
+        hash: string;
+    } | {
+        op: "clear";
+    })[]>;
+    entitiesPatch: v.Optional<({
+        op: "put";
+        entityType: string;
+        entityID: Record<string, string>;
+        value: import("../../replicache").ReadonlyJSONObject;
+    } | {
+        merge?: import("../../replicache").ReadonlyJSONObject | undefined;
+        constrain?: string[] | undefined;
+        op: "update";
+        entityType: string;
+        entityID: Record<string, string>;
+    } | {
+        op: "del";
+        entityType: string;
+        entityID: Record<string, string>;
+    } | {
+        op: "clear";
+    })[]>;
+}, undefined>;
+export declare const pokeEndBodySchema: v.ObjectType<{
+    pokeID: v.Type<string>;
+}, undefined>;
+export declare const pokeStartMessageSchema: v.ArrayType<[v.Type<"pokeStart">, v.ObjectType<{
+    pokeID: v.Type<string>;
+    baseCookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
+    cookie: v.Type<string>;
+    timestamp: v.Optional<number>;
+}, undefined>], undefined>;
+export declare const pokePartMessageSchema: v.ArrayType<[v.Type<"pokePart">, v.ObjectType<{
+    pokeID: v.Type<string>;
+    lastMutationIDChanges: v.Optional<Record<string, number>>;
+    clientsPatch: v.Optional<({
+        op: "put";
+        clientID: string;
+    } | {
+        op: "del";
+        clientID: string;
+    } | {
+        op: "clear";
+    })[]>;
+    desiredQueriesPatches: v.Optional<Record<string, ({
+        op: "put";
+        hash: string;
+        ast: {
+            schema?: string | undefined;
+            alias?: string | undefined;
+            where?: readonly {
+                type: "simple";
+                op: "=" | "!=" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+                field: string;
+                value: string | number | boolean | readonly (string | number | boolean)[] | {
+                    type: "static";
+                    anchor: "authData" | "preMutationRow";
+                    field: string;
+                };
+            }[] | undefined;
+            related?: readonly import("../../zql/src/zql/ast/ast.js").CorrelatedSubQuery[] | undefined;
+            limit?: number | undefined;
+            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
+            start?: {
+                row: Record<string, string | number | boolean | null | undefined>;
+                exclusive: boolean;
+            } | undefined;
+            table: string;
+        };
+    } | {
+        op: "del";
+        hash: string;
+    } | {
+        op: "clear";
+    })[]>>;
+    gotQueriesPatch: v.Optional<({
+        op: "put";
+        hash: string;
+        ast: {
+            schema?: string | undefined;
+            alias?: string | undefined;
+            where?: readonly {
+                type: "simple";
+                op: "=" | "!=" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+                field: string;
+                value: string | number | boolean | readonly (string | number | boolean)[] | {
+                    type: "static";
+                    anchor: "authData" | "preMutationRow";
+                    field: string;
+                };
+            }[] | undefined;
+            related?: readonly import("../../zql/src/zql/ast/ast.js").CorrelatedSubQuery[] | undefined;
+            limit?: number | undefined;
+            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
+            start?: {
+                row: Record<string, string | number | boolean | null | undefined>;
+                exclusive: boolean;
+            } | undefined;
+            table: string;
+        };
+    } | {
+        op: "del";
+        hash: string;
+    } | {
+        op: "clear";
+    })[]>;
+    entitiesPatch: v.Optional<({
+        op: "put";
+        entityType: string;
+        entityID: Record<string, string>;
+        value: import("../../replicache").ReadonlyJSONObject;
+    } | {
+        merge?: import("../../replicache").ReadonlyJSONObject | undefined;
+        constrain?: string[] | undefined;
+        op: "update";
+        entityType: string;
+        entityID: Record<string, string>;
+    } | {
+        op: "del";
+        entityType: string;
+        entityID: Record<string, string>;
+    } | {
+        op: "clear";
+    })[]>;
+}, undefined>], undefined>;
+export declare const pokeEndMessageSchema: v.ArrayType<[v.Type<"pokeEnd">, v.ObjectType<{
+    pokeID: v.Type<string>;
+}, undefined>], undefined>;
+export type PokeStartBody = v.Infer<typeof pokeStartBodySchema>;
+export type PokePartBody = v.Infer<typeof pokePartBodySchema>;
+export type PokeEndBody = v.Infer<typeof pokeEndBodySchema>;
+export type PokeStartMessage = v.Infer<typeof pokeStartMessageSchema>;
+export type PokePartMessage = v.Infer<typeof pokePartMessageSchema>;
+export type PokeEndMessage = v.Infer<typeof pokeEndMessageSchema>;
+//# sourceMappingURL=poke.d.ts.map

package/out/zero-protocol/src/poke.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"poke.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAM1C;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,mBAAmB;;;;;aAQ9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;aAE5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;0BAGjC,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAGhC,CAAC;AACH,eAAO,MAAM,oBAAoB;;0BAG/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

package/out/zero-protocol/src/poke.js

@@ -0,0 +1,69 @@
+import * as v from '../../shared/src/valita.js';
+import { nullableVersionSchema, versionSchema } from './version.js';
+import { clientsPatchSchema } from './clients-patch.js';
+import { queriesPatchSchema } from './queries-patch.js';
+import { entitiesPatchSchema } from './entities-patch.js';
+/**
+ * Pokes use a multi-part format. Pokes send entity data to the client and can
+ * be multiple mega-bytes in size. Using a multi-part format allows the server
+ * to avoid having to have the full poke in memory at one time.
+ *
+ * Each poke is assigned a `pokeID`, a unique id (within the context of the
+ * connection) for identifying the poke.  All messages for a poke will have the
+ * same `pokeID`.
+ *
+ * A poke begins with a `poke-start` message which contains the `baseCookie`
+ * the poke is updating from and the `cookie` the poke is updating to.
+ *
+ * The poke continues with zero to many `poke-part` messages, each of which
+ * can contain patch parts.  These patch parts should be merged in the order
+ * received.
+ *
+ * Finally, the poke ends with a `poke-end` message.  The merged `poke-parts`
+ * can now be applied as a whole to update from `baseCookie` to `cookie`.
+ *
+ * Poke messages can be intermingled with other `down` messages, but cannot be
+ * intermingled with poke messages for a different `pokeID`. If this is
+ * observed it is an unexpected error; the client should ignore both pokes,
+ * disconnect, and reconnect.
+ */
+export const pokeStartBodySchema = v.object({
+    pokeID: v.string(),
+    // We always specify a Version as our cookie, but Replicache starts clients
+    // with initial cookie `null`, before the first request. So we have to be
+    // able to send a base cookie with value `null` to match that state.
+    baseCookie: nullableVersionSchema,
+    cookie: versionSchema,
+    timestamp: v.number().optional(),
+});
+export const pokePartBodySchema = v.object({
+    pokeID: v.string(),
+    // Changes to last mutation id by client id.
+    lastMutationIDChanges: v.record(v.number()).optional(),
+    // Patches to the set of "alive" clients (according to server) belonging to
+    // this client group.
+    clientsPatch: clientsPatchSchema.optional(),
+    // Patches to the desired query sets by client id.
+    desiredQueriesPatches: v.record(queriesPatchSchema).optional(),
+    // Patches to the set of queries for which entities are sync'd in
+    // entitiesPatch.
+    gotQueriesPatch: queriesPatchSchema.optional(),
+    // Patches to the entities set.
+    entitiesPatch: entitiesPatchSchema.optional(),
+});
+export const pokeEndBodySchema = v.object({
+    pokeID: v.string(),
+});
+export const pokeStartMessageSchema = v.tuple([
+    v.literal('pokeStart'),
+    pokeStartBodySchema,
+]);
+export const pokePartMessageSchema = v.tuple([
+    v.literal('pokePart'),
+    pokePartBodySchema,
+]);
+export const pokeEndMessageSchema = v.tuple([
+    v.literal('pokeEnd'),
+    pokeEndBodySchema,
+]);
+//# sourceMappingURL=poke.js.map

package/out/zero-protocol/src/poke.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"poke.js","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,cAAc,CAAC;AAClE,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,mBAAmB,EAAC,MAAM,qBAAqB,CAAC;AAExD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,2EAA2E;IAC3E,yEAAyE;IACzE,oEAAoE;IACpE,UAAU,EAAE,qBAAqB;IACjC,MAAM,EAAE,aAAa;IACrB,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,4CAA4C;IAC5C,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACtD,2EAA2E;IAC3E,qBAAqB;IACrB,YAAY,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,kDAAkD;IAClD,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE;IAC9D,iEAAiE;IACjE,iBAAiB;IACjB,eAAe,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC9C,+BAA+B;IAC/B,aAAa,EAAE,mBAAmB,CAAC,QAAQ,EAAE;CAC9C,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;CACnB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC5C,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IACtB,mBAAmB;CACpB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC3C,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;IACrB,kBAAkB;CACnB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC1C,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACpB,iBAAiB;CAClB,CAAC,CAAC"}

package/out/zero-protocol/src/pong.d.ts

@@ -0,0 +1,6 @@
+import * as v from '../../shared/src/valita.js';
+export declare const pongBodySchema: v.ObjectType<{}, undefined>;
+export declare const pongMessageSchema: v.ArrayType<[v.Type<"pong">, v.ObjectType<{}, undefined>], undefined>;
+export type PongBody = v.Infer<typeof pongBodySchema>;
+export type PongMessage = v.Infer<typeof pongMessageSchema>;
+//# sourceMappingURL=pong.d.ts.map

package/out/zero-protocol/src/pong.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pong.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/pong.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAE1C,eAAO,MAAM,cAAc,6BAAe,CAAC;AAC3C,eAAO,MAAM,iBAAiB,uEAA+C,CAAC;AAE9E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}

package/out/zero-protocol/src/pong.js

@@ -0,0 +1,4 @@
+import * as v from '../../shared/src/valita.js';
+export const pongBodySchema = v.object({});
+export const pongMessageSchema = v.tuple([v.literal('pong'), pongBodySchema]);
+//# sourceMappingURL=pong.js.map

package/out/zero-protocol/src/pong.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pong.js","sourceRoot":"","sources":["../../../../zero-protocol/src/pong.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAE1C,MAAM,CAAC,MAAM,cAAc,GAAG,CAAC,CAAC,MAAM,CAAC,EAAE,CAAC,CAAC;AAC3C,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC"}

package/out/zero-protocol/src/pull.d.ts

@@ -0,0 +1,26 @@
+import * as v from '../../shared/src/valita.js';
+export declare const pullRequestBodySchema: v.ObjectType<{
+    clientGroupID: v.Type<string>;
+    cookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
+    requestID: v.Type<string>;
+}, undefined>;
+export declare const pullResponseBodySchema: v.ObjectType<{
+    cookie: v.Type<string>;
+    requestID: v.Type<string>;
+    lastMutationIDChanges: v.Type<Record<string, number>>;
+}, undefined>;
+export declare const pullRequestMessageSchema: v.ArrayType<[v.Type<"pull">, v.ObjectType<{
+    clientGroupID: v.Type<string>;
+    cookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
+    requestID: v.Type<string>;
+}, undefined>], undefined>;
+export declare const pullResponseMessageSchema: v.ArrayType<[v.Type<"pull">, v.ObjectType<{
+    cookie: v.Type<string>;
+    requestID: v.Type<string>;
+    lastMutationIDChanges: v.Type<Record<string, number>>;
+}, undefined>], undefined>;
+export type PullRequestBody = v.Infer<typeof pullRequestBodySchema>;
+export type PullResponseBody = v.Infer<typeof pullResponseBodySchema>;
+export type PullRequestMessage = v.Infer<typeof pullRequestMessageSchema>;
+export type PullResponseMessage = v.Infer<typeof pullResponseMessageSchema>;
+//# sourceMappingURL=pull.d.ts.map

package/out/zero-protocol/src/pull.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/pull.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAG1C,eAAO,MAAM,qBAAqB;;;;aAIhC,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;aAOjC,CAAC;AAEH,eAAO,MAAM,wBAAwB;;;;0BAGnC,CAAC;AAEH,eAAO,MAAM,yBAAyB;;;;0BAGpC,CAAC;AAEH,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,wBAAwB,CAAC,CAAC;AAC1E,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/out/zero-protocol/src/pull.js

@@ -0,0 +1,24 @@
+import * as v from '../../shared/src/valita.js';
+import { nullableVersionSchema, versionSchema } from './version.js';
+export const pullRequestBodySchema = v.object({
+    clientGroupID: v.string(),
+    cookie: nullableVersionSchema,
+    requestID: v.string(),
+});
+export const pullResponseBodySchema = v.object({
+    cookie: versionSchema,
+    // Matches pullRequestBodySchema requestID that initiated this response
+    requestID: v.string(),
+    lastMutationIDChanges: v.record(v.number()),
+    // Pull is currently only used for mutation recovery which does not use
+    // the patch so we save work by not computing the patch.
+});
+export const pullRequestMessageSchema = v.tuple([
+    v.literal('pull'),
+    pullRequestBodySchema,
+]);
+export const pullResponseMessageSchema = v.tuple([
+    v.literal('pull'),
+    pullResponseBodySchema,
+]);
+//# sourceMappingURL=pull.js.map

package/out/zero-protocol/src/pull.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"pull.js","sourceRoot":"","sources":["../../../../zero-protocol/src/pull.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAC1C,OAAO,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,cAAc,CAAC;AAElE,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC5C,aAAa,EAAE,CAAC,CAAC,MAAM,EAAE;IACzB,MAAM,EAAE,qBAAqB;IAC7B,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;CACtB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC7C,MAAM,EAAE,aAAa;IACrB,uEAAuE;IACvE,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE;IACrB,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC;IAC3C,uEAAuE;IACvE,wDAAwD;CACzD,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,wBAAwB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC9C,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACjB,qBAAqB;CACtB,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC/C,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC;IACjB,sBAAsB;CACvB,CAAC,CAAC"}

package/out/zero-protocol/src/push.d.ts

@@ -0,0 +1,257 @@
+import * as v from '../../shared/src/valita.js';
+export declare const CRUD_MUTATION_NAME = "_zero_crud";
+export declare enum MutationType {
+    CRUD = "crud",
+    Custom = "custom"
+}
+/**
+ * Inserts if entity with id does not already exist.
+ */
+declare const createOpSchema: v.ObjectType<{
+    op: v.Type<"create">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+    value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+}, undefined>;
+/**
+ * Upsert semantics. Inserts if entity with id does not already exist,
+ * otherwise updates existing entity with id.
+ */
+declare const setOpSchema: v.ObjectType<{
+    op: v.Type<"set">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+    value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+}, undefined>;
+/**
+ * Updates if entity with id exists, otherwise does nothing.
+ */
+declare const updateOpSchema: v.ObjectType<{
+    op: v.Type<"update">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+    partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+}, undefined>;
+/**
+ * Deletes entity with id if it exists, otherwise does nothing.
+ */
+declare const deleteOpSchema: v.ObjectType<{
+    op: v.Type<"delete">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+}, undefined>;
+declare const crudOpSchema: v.UnionType<[v.ObjectType<{
+    op: v.Type<"create">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+    value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+}, undefined>, v.ObjectType<{
+    op: v.Type<"set">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+    value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+}, undefined>, v.ObjectType<{
+    op: v.Type<"update">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+    partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+}, undefined>, v.ObjectType<{
+    op: v.Type<"delete">;
+    entityType: v.Type<string>;
+    id: v.Type<Record<string, string>>;
+}, undefined>]>;
+declare const crudArgSchema: v.ObjectType<{
+    ops: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+        op: v.Type<"create">;
+        entityType: v.Type<string>;
+        id: v.Type<Record<string, string>>;
+        value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+    }, undefined>, v.ObjectType<{
+        op: v.Type<"set">;
+        entityType: v.Type<string>;
+        id: v.Type<Record<string, string>>;
+        value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+    }, undefined>, v.ObjectType<{
+        op: v.Type<"update">;
+        entityType: v.Type<string>;
+        id: v.Type<Record<string, string>>;
+        partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+    }, undefined>, v.ObjectType<{
+        op: v.Type<"delete">;
+        entityType: v.Type<string>;
+        id: v.Type<Record<string, string>>;
+    }, undefined>]>>;
+}, undefined>;
+export declare const crudMutationSchema: v.ObjectType<{
+    type: v.Type<MutationType.CRUD>;
+    id: v.Type<number>;
+    clientID: v.Type<string>;
+    name: v.Type<"_zero_crud">;
+    args: v.ArrayType<[v.ObjectType<{
+        ops: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+            op: v.Type<"create">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+            value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+        }, undefined>, v.ObjectType<{
+            op: v.Type<"set">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+            value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+        }, undefined>, v.ObjectType<{
+            op: v.Type<"update">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+            partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+        }, undefined>, v.ObjectType<{
+            op: v.Type<"delete">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+        }, undefined>]>>;
+    }, undefined>], undefined>;
+    timestamp: v.Type<number>;
+}, undefined>;
+export declare const customMutationSchema: v.ObjectType<{
+    type: v.Type<MutationType.Custom>;
+    id: v.Type<number>;
+    clientID: v.Type<string>;
+    name: v.Type<string>;
+    args: v.ArrayType<[], v.Type<import("../../replicache").ReadonlyJSONValue>>;
+    timestamp: v.Type<number>;
+}, undefined>;
+export declare const mutationSchema: v.UnionType<[v.ObjectType<{
+    type: v.Type<MutationType.CRUD>;
+    id: v.Type<number>;
+    clientID: v.Type<string>;
+    name: v.Type<"_zero_crud">;
+    args: v.ArrayType<[v.ObjectType<{
+        ops: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+            op: v.Type<"create">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+            value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+        }, undefined>, v.ObjectType<{
+            op: v.Type<"set">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+            value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+        }, undefined>, v.ObjectType<{
+            op: v.Type<"update">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+            partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+        }, undefined>, v.ObjectType<{
+            op: v.Type<"delete">;
+            entityType: v.Type<string>;
+            id: v.Type<Record<string, string>>;
+        }, undefined>]>>;
+    }, undefined>], undefined>;
+    timestamp: v.Type<number>;
+}, undefined>, v.ObjectType<{
+    type: v.Type<MutationType.Custom>;
+    id: v.Type<number>;
+    clientID: v.Type<string>;
+    name: v.Type<string>;
+    args: v.ArrayType<[], v.Type<import("../../replicache").ReadonlyJSONValue>>;
+    timestamp: v.Type<number>;
+}, undefined>]>;
+export declare const pushBodySchema: v.ObjectType<{
+    clientGroupID: v.Type<string>;
+    mutations: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+        type: v.Type<MutationType.CRUD>;
+        id: v.Type<number>;
+        clientID: v.Type<string>;
+        name: v.Type<"_zero_crud">;
+        args: v.ArrayType<[v.ObjectType<{
+            ops: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+                op: v.Type<"create">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+                value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+            }, undefined>, v.ObjectType<{
+                op: v.Type<"set">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+                value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+            }, undefined>, v.ObjectType<{
+                op: v.Type<"update">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+                partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+            }, undefined>, v.ObjectType<{
+                op: v.Type<"delete">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+            }, undefined>]>>;
+        }, undefined>], undefined>;
+        timestamp: v.Type<number>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<MutationType.Custom>;
+        id: v.Type<number>;
+        clientID: v.Type<string>;
+        name: v.Type<string>;
+        args: v.ArrayType<[], v.Type<import("../../replicache").ReadonlyJSONValue>>;
+        timestamp: v.Type<number>;
+    }, undefined>]>>;
+    pushVersion: v.Type<number>;
+    schemaVersion: v.Type<number>;
+    timestamp: v.Type<number>;
+    requestID: v.Type<string>;
+}, undefined>;
+export declare const pushMessageSchema: v.ArrayType<[v.Type<"push">, v.ObjectType<{
+    clientGroupID: v.Type<string>;
+    mutations: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+        type: v.Type<MutationType.CRUD>;
+        id: v.Type<number>;
+        clientID: v.Type<string>;
+        name: v.Type<"_zero_crud">;
+        args: v.ArrayType<[v.ObjectType<{
+            ops: v.ArrayType<[], v.UnionType<[v.ObjectType<{
+                op: v.Type<"create">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+                value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+            }, undefined>, v.ObjectType<{
+                op: v.Type<"set">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+                value: v.Type<import("../../replicache").ReadonlyJSONObject>;
+            }, undefined>, v.ObjectType<{
+                op: v.Type<"update">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+                partialValue: v.Type<import("../../replicache").ReadonlyJSONObject>;
+            }, undefined>, v.ObjectType<{
+                op: v.Type<"delete">;
+                entityType: v.Type<string>;
+                id: v.Type<Record<string, string>>;
+            }, undefined>]>>;
+        }, undefined>], undefined>;
+        timestamp: v.Type<number>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<MutationType.Custom>;
+        id: v.Type<number>;
+        clientID: v.Type<string>;
+        name: v.Type<string>;
+        args: v.ArrayType<[], v.Type<import("../../replicache").ReadonlyJSONValue>>;
+        timestamp: v.Type<number>;
+    }, undefined>]>>;
+    pushVersion: v.Type<number>;
+    schemaVersion: v.Type<number>;
+    timestamp: v.Type<number>;
+    requestID: v.Type<string>;
+}, undefined>], undefined>;
+export type CreateOp = v.Infer<typeof createOpSchema>;
+export type SetOp = v.Infer<typeof setOpSchema>;
+export type UpdateOp = v.Infer<typeof updateOpSchema>;
+export type DeleteOp = v.Infer<typeof deleteOpSchema>;
+export type CRUDOp = v.Infer<typeof crudOpSchema>;
+export type CRUDOpKind = CRUDOp['op'];
+export type CRUDMutationArg = v.Infer<typeof crudArgSchema>;
+export type CRUDMutation = v.Infer<typeof crudMutationSchema>;
+export type CustomMutation = v.Infer<typeof customMutationSchema>;
+export type Mutation = v.Infer<typeof mutationSchema>;
+export type PushBody = v.Infer<typeof pushBodySchema>;
+export type PushMessage = v.Infer<typeof pushMessageSchema>;
+export {};
+//# sourceMappingURL=push.d.ts.map

package/out/zero-protocol/src/push.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"push.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/push.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,sBAAsB,CAAC;AAG1C,eAAO,MAAM,kBAAkB,eAAe,CAAC;AAC/C,oBAAY,YAAY;IACtB,IAAI,SAAS;IACb,MAAM,WAAW;CAClB;AAED;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAKlB,CAAC;AAEH;;;GAGG;AACH,QAAA,MAAM,WAAW;;;;;aAKf,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,cAAc;;;;;aAKlB,CAAC;AAEH;;GAEG;AACH,QAAA,MAAM,cAAc;;;;aAIlB,CAAC;AAEH,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;eAKjB,CAAC;AAEF,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;aAEjB,CAAC;AAIH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAO7B,CAAC;AAEH,eAAO,MAAM,oBAAoB;;;;;;;aAO/B,CAAC;AAEH,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAAoD,CAAC;AAEhF,eAAO,MAAM,cAAc;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAOzB,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0BAA+C,CAAC;AAE9E,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAChD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAClD,MAAM,MAAM,UAAU,GAAG,MAAM,CAAC,IAAI,CAAC,CAAC;AACtC,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAC5D,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC;AAClE,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,cAAc,CAAC,CAAC;AACtD,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC"}