@rocicorp/zero 0.10.2025010800 → 0.10.2025011100

package/out/zero-cache/src/services/change-source/protocol/current/downstream.d.ts

@@ -0,0 +1,469 @@
+import * as v from '../../../../../../shared/src/valita.js';
+declare const begin: v.TupleType<[v.Type<"begin">, v.ObjectType<{
+    tag: v.Type<"begin">;
+}, undefined>]>;
+declare const data: v.TupleType<[v.Type<"data">, v.UnionType<[v.ObjectType<{
+    tag: v.Type<"insert">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    new: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    key: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue> | null>;
+    old: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue> | null>;
+    new: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"delete">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    key: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"truncate">;
+    relations: v.ArrayType<v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-table">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        columns: v.Type<Record<string, {
+            pgTypeClass?: import("../../../../db/specs.js").PostgresTypeClass | undefined;
+            characterMaximumLength?: number | null | undefined;
+            notNull?: boolean | null | undefined;
+            dflt?: string | null | undefined;
+            pos: number;
+            dataType: string;
+        }>>;
+        primaryKey: v.ArrayType<v.Type<string>>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"rename-table">;
+    old: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    new: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"add-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    old: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+    new: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.Type<string>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-table">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-index">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        tableName: v.Type<string>;
+        unique: v.Type<boolean>;
+        columns: v.Type<Record<string, "ASC" | "DESC">>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-index">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>]>]>;
+declare const commit: v.TupleType<[v.Type<"commit">, v.ObjectType<{
+    tag: v.Type<"commit">;
+}, undefined>, v.ObjectType<{
+    watermark: v.Type<string>;
+}, undefined>]>;
+declare const rollback: v.TupleType<[v.Type<"rollback">, v.ObjectType<{
+    tag: v.Type<"rollback">;
+}, undefined>]>;
+export type Begin = v.Infer<typeof begin>;
+export type Data = v.Infer<typeof data>;
+export type Commit = v.Infer<typeof commit>;
+export type Rollback = v.Infer<typeof rollback>;
+export declare const changeStreamDataSchema: v.UnionType<[v.TupleType<[v.Type<"begin">, v.ObjectType<{
+    tag: v.Type<"begin">;
+}, undefined>]>, v.TupleType<[v.Type<"data">, v.UnionType<[v.ObjectType<{
+    tag: v.Type<"insert">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    new: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    key: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue> | null>;
+    old: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue> | null>;
+    new: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"delete">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    key: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"truncate">;
+    relations: v.ArrayType<v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-table">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        columns: v.Type<Record<string, {
+            pgTypeClass?: import("../../../../db/specs.js").PostgresTypeClass | undefined;
+            characterMaximumLength?: number | null | undefined;
+            notNull?: boolean | null | undefined;
+            dflt?: string | null | undefined;
+            pos: number;
+            dataType: string;
+        }>>;
+        primaryKey: v.ArrayType<v.Type<string>>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"rename-table">;
+    old: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    new: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"add-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    old: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+    new: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.Type<string>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-table">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-index">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        tableName: v.Type<string>;
+        unique: v.Type<boolean>;
+        columns: v.Type<Record<string, "ASC" | "DESC">>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-index">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>]>]>, v.TupleType<[v.Type<"commit">, v.ObjectType<{
+    tag: v.Type<"commit">;
+}, undefined>, v.ObjectType<{
+    watermark: v.Type<string>;
+}, undefined>]>, v.TupleType<[v.Type<"rollback">, v.ObjectType<{
+    tag: v.Type<"rollback">;
+}, undefined>]>]>;
+export type ChangeStreamData = v.Infer<typeof changeStreamDataSchema>;
+export declare const changeStreamControlSchema: v.TupleType<[v.Type<"control">, v.ObjectType<{
+    tag: v.Type<"reset-required">;
+}, undefined>]>;
+export type ChangeStreamControl = v.Infer<typeof changeStreamControlSchema>;
+/** Downstream messages consist of data plane and control plane messages. */
+export declare const changeStreamMessageSchema: v.UnionType<[v.UnionType<[v.TupleType<[v.Type<"begin">, v.ObjectType<{
+    tag: v.Type<"begin">;
+}, undefined>]>, v.TupleType<[v.Type<"data">, v.UnionType<[v.ObjectType<{
+    tag: v.Type<"insert">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    new: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    key: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue> | null>;
+    old: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue> | null>;
+    new: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"delete">;
+    relation: v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>;
+    key: v.Type<Record<string, import("../../../../types/bigint-json.js").JSONValue>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"truncate">;
+    relations: v.ArrayType<v.ObjectType<{
+        tag: v.Type<"relation">;
+        schema: v.Type<string>;
+        name: v.Type<string>;
+        replicaIdentity: v.UnionType<[v.Type<"default">, v.Type<"nothing">, v.Type<"full">, v.Type<"index">]>;
+        keyColumns: v.ArrayType<v.Type<string>>;
+    }, undefined>>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-table">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        columns: v.Type<Record<string, {
+            pgTypeClass?: import("../../../../db/specs.js").PostgresTypeClass | undefined;
+            characterMaximumLength?: number | null | undefined;
+            notNull?: boolean | null | undefined;
+            dflt?: string | null | undefined;
+            pos: number;
+            dataType: string;
+        }>>;
+        primaryKey: v.ArrayType<v.Type<string>>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"rename-table">;
+    old: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    new: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"add-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"update-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    old: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+    new: v.ObjectType<{
+        name: v.Type<string>;
+        spec: v.ObjectType<{
+            pos: v.Type<number>;
+            dataType: v.Type<string>;
+            pgTypeClass: v.Optional<import("../../../../db/specs.js").PostgresTypeClass>;
+            characterMaximumLength: v.Optional<number | null>;
+            notNull: v.Optional<boolean | null>;
+            dflt: v.Optional<string | null>;
+        }, undefined>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-column">;
+    table: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+    column: v.Type<string>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-table">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"create-index">;
+    spec: v.ObjectType<Omit<{
+        name: v.Type<string>;
+        tableName: v.Type<string>;
+        unique: v.Type<boolean>;
+        columns: v.Type<Record<string, "ASC" | "DESC">>;
+    }, "schema"> & {
+        schema: v.Type<string>;
+    }, undefined>;
+}, undefined>, v.ObjectType<{
+    tag: v.Type<"drop-index">;
+    id: v.ObjectType<{
+        schema: v.Type<string>;
+        name: v.Type<string>;
+    }, undefined>;
+}, undefined>]>]>, v.TupleType<[v.Type<"commit">, v.ObjectType<{
+    tag: v.Type<"commit">;
+}, undefined>, v.ObjectType<{
+    watermark: v.Type<string>;
+}, undefined>]>, v.TupleType<[v.Type<"rollback">, v.ObjectType<{
+    tag: v.Type<"rollback">;
+}, undefined>]>]>, v.TupleType<[v.Type<"control">, v.ObjectType<{
+    tag: v.Type<"reset-required">;
+}, undefined>]>]>;
+export type ChangeStreamMessage = v.Infer<typeof changeStreamMessageSchema>;
+export {};
+//# sourceMappingURL=downstream.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/current/downstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"downstream.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/downstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,wCAAwC,CAAC;AAS5D,QAAA,MAAM,KAAK;;eAA6C,CAAC;AACzD,QAAA,MAAM,IAAI;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAiD,CAAC;AAC5D,QAAA,MAAM,MAAM;;;;eAIV,CAAC;AACH,QAAA,MAAM,QAAQ;;eAAmD,CAAC;AAElE,MAAM,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,KAAK,CAAC,CAAC;AAC1C,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,IAAI,CAAC,CAAC;AACxC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC;AAC5C,MAAM,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,QAAQ,CAAC,CAAC;AAEhD,eAAO,MAAM,sBAAsB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAAyC,CAAC;AAC7E,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AAEtE,eAAO,MAAM,yBAAyB;;eAGpC,CAAC;AACH,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC;AAE5E,4EAA4E;AAC5E,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAGrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/downstream.js

@@ -0,0 +1,19 @@
+import * as v from '../../../../../../shared/src/valita.js';
+import { resetRequiredSchema } from './control.js';
+import { beginSchema, commitSchema, dataChangeSchema, rollbackSchema, } from './data.js';
+const begin = v.tuple([v.literal('begin'), beginSchema]);
+const data = v.tuple([v.literal('data'), dataChangeSchema]);
+const commit = v.tuple([
+    v.literal('commit'),
+    commitSchema,
+    v.object({ watermark: v.string() }),
+]);
+const rollback = v.tuple([v.literal('rollback'), rollbackSchema]);
+export const changeStreamDataSchema = v.union(begin, data, commit, rollback);
+export const changeStreamControlSchema = v.tuple([
+    v.literal('control'),
+    resetRequiredSchema, // TODO: Add statusRequestedSchema
+]);
+/** Downstream messages consist of data plane and control plane messages. */
+export const changeStreamMessageSchema = v.union(changeStreamDataSchema, changeStreamControlSchema);
+//# sourceMappingURL=downstream.js.map

package/out/zero-cache/src/services/change-source/protocol/current/downstream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"downstream.js","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/downstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,wCAAwC,CAAC;AAC5D,OAAO,EAAC,mBAAmB,EAAC,MAAM,cAAc,CAAC;AACjD,OAAO,EACL,WAAW,EACX,YAAY,EACZ,gBAAgB,EAChB,cAAc,GACf,MAAM,WAAW,CAAC;AAEnB,MAAM,KAAK,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,WAAW,CAAC,CAAC,CAAC;AACzD,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,MAAM,CAAC,EAAE,gBAAgB,CAAC,CAAC,CAAC;AAC5D,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC;IACrB,CAAC,CAAC,OAAO,CAAC,QAAQ,CAAC;IACnB,YAAY;IACZ,CAAC,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,EAAC,CAAC;CAClC,CAAC,CAAC;AACH,MAAM,QAAQ,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC,EAAE,cAAc,CAAC,CAAC,CAAC;AAOlE,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC,KAAK,EAAE,IAAI,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC;AAG7E,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC/C,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACpB,mBAAmB,EAAE,kCAAkC;CACxD,CAAC,CAAC;AAGH,4EAA4E;AAC5E,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,KAAK,CAC9C,sBAAsB,EACtB,yBAAyB,CAC1B,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/mod.d.ts

@@ -0,0 +1,6 @@
+export * from './control.js';
+export * from './data.js';
+export * from './downstream.js';
+export * from './path.js';
+export * from './upstream.js';
+//# sourceMappingURL=mod.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/current/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/mod.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/mod.js

@@ -0,0 +1,6 @@
+export * from './control.js';
+export * from './data.js';
+export * from './downstream.js';
+export * from './path.js';
+export * from './upstream.js';
+//# sourceMappingURL=mod.js.map

package/out/zero-cache/src/services/change-source/protocol/current/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/mod.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC;AAC1B,cAAc,iBAAiB,CAAC;AAChC,cAAc,WAAW,CAAC;AAC1B,cAAc,eAAe,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/path.d.ts

@@ -0,0 +1,20 @@
+/**
+ * The path required for a custom Change Source endpoint implementing the
+ * Change Source protocol. The version in the path indicates the current
+ * (i.e. latest) protocol version of the code, and is the only protocol
+ * supported by the code.
+ *
+ * Eventually, when a backwards incompatible change is made to the protocol,
+ * the version will be bumped to ensure that the protocol is only used for an
+ * endpoint that explicitly understands it. (While the protocol is in flux
+ * and being developed, a starting "v0" version will not follow this
+ * convention.)
+ *
+ * Historic versions are kept in the source code (e.g. v1, v2, etc.) to
+ * allow Change Source implementations to import and support multiple
+ * versions simultaneously. This is necessary to seamlessly transitioning
+ * from a `zero-cache` speaking one version to a `zero-cache` speaking
+ * another.
+ */
+export declare const CHANGE_SOURCE_PATH = "/changes/v0/stream";
+//# sourceMappingURL=path.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/current/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,eAAO,MAAM,kBAAkB,uBAAuB,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/path.js

@@ -0,0 +1,20 @@
+/**
+ * The path required for a custom Change Source endpoint implementing the
+ * Change Source protocol. The version in the path indicates the current
+ * (i.e. latest) protocol version of the code, and is the only protocol
+ * supported by the code.
+ *
+ * Eventually, when a backwards incompatible change is made to the protocol,
+ * the version will be bumped to ensure that the protocol is only used for an
+ * endpoint that explicitly understands it. (While the protocol is in flux
+ * and being developed, a starting "v0" version will not follow this
+ * convention.)
+ *
+ * Historic versions are kept in the source code (e.g. v1, v2, etc.) to
+ * allow Change Source implementations to import and support multiple
+ * versions simultaneously. This is necessary to seamlessly transitioning
+ * from a `zero-cache` speaking one version to a `zero-cache` speaking
+ * another.
+ */
+export const CHANGE_SOURCE_PATH = '/changes/v0/stream';
+//# sourceMappingURL=path.js.map

package/out/zero-cache/src/services/change-source/protocol/current/path.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.js","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/path.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,oBAAoB,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/upstream.d.ts

@@ -0,0 +1,17 @@
+import * as v from '../../../../../../shared/src/valita.js';
+/**
+ * An acknowledgement is sent from the Change Streamer to the Change Source to
+ * either or both:
+ * * Indicate that it is connected and running, e.g. in response to an
+ *   "ack-requested" message.
+ * * Indicate that it is caught up to a specific `watermark`.
+ */
+export declare const ackSchema: v.UnionType<[v.TupleType<[v.Type<"ack">]>, v.TupleType<[v.Type<"ack">, v.ObjectType<{
+    watermark: v.Type<string>;
+}, undefined>]>]>;
+/** At the moment, the only upstream messages are acks.  */
+export declare const changeSourceUpstreamSchema: v.UnionType<[v.TupleType<[v.Type<"ack">]>, v.TupleType<[v.Type<"ack">, v.ObjectType<{
+    watermark: v.Type<string>;
+}, undefined>]>]>;
+export type ChangeSourceUpstream = v.Infer<typeof changeSourceUpstreamSchema>;
+//# sourceMappingURL=upstream.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/current/upstream.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.d.ts","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/upstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,wCAAwC,CAAC;AAE5D;;;;;;GAMG;AACH,eAAO,MAAM,SAAS;;iBAGrB,CAAC;AAEF,2DAA2D;AAC3D,eAAO,MAAM,0BAA0B;;iBAAY,CAAC;AACpD,MAAM,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,0BAA0B,CAAC,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/current/upstream.js

@@ -0,0 +1,12 @@
+import * as v from '../../../../../../shared/src/valita.js';
+/**
+ * An acknowledgement is sent from the Change Streamer to the Change Source to
+ * either or both:
+ * * Indicate that it is connected and running, e.g. in response to an
+ *   "ack-requested" message.
+ * * Indicate that it is caught up to a specific `watermark`.
+ */
+export const ackSchema = v.union(v.tuple([v.literal('ack')]), v.tuple([v.literal('ack'), v.object({ watermark: v.string() })]));
+/** At the moment, the only upstream messages are acks.  */
+export const changeSourceUpstreamSchema = ackSchema;
+//# sourceMappingURL=upstream.js.map

package/out/zero-cache/src/services/change-source/protocol/current/upstream.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"upstream.js","sourceRoot":"","sources":["../../../../../../../../zero-cache/src/services/change-source/protocol/current/upstream.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,wCAAwC,CAAC;AAE5D;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG,CAAC,CAAC,KAAK,CAC9B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAC3B,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,MAAM,CAAC,EAAC,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,EAAC,CAAC,CAAC,CAAC,CAC/D,CAAC;AAEF,2DAA2D;AAC3D,MAAM,CAAC,MAAM,0BAA0B,GAAG,SAAS,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/mod.d.ts

@@ -0,0 +1,2 @@
+export * as v0 from './current/mod.js';
+//# sourceMappingURL=mod.d.ts.map

package/out/zero-cache/src/services/change-source/protocol/mod.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.d.ts","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/protocol/mod.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC"}

package/out/zero-cache/src/services/change-source/protocol/mod.js

@@ -0,0 +1,5 @@
+// Types are externally exported under stable versions. Code within
+// zero-cache, on the contrary, should reference the files in
+// current/* so that it is versioned with the latest version.
+export * as v0 from './current/mod.js';
+//# sourceMappingURL=mod.js.map

package/out/zero-cache/src/services/change-source/protocol/mod.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mod.js","sourceRoot":"","sources":["../../../../../../../zero-cache/src/services/change-source/protocol/mod.ts"],"names":[],"mappings":"AAAA,mEAAmE;AACnE,6DAA6D;AAC7D,6DAA6D;AAC7D,OAAO,KAAK,EAAE,MAAM,kBAAkB,CAAC"}