@rocicorp/zero 0.6.2024112101 → 0.7.2024112700

package/out/zero-schema/src/compiled-authorization.d.ts

@@ -1,9 +1,62 @@
 import * as v from '../../shared/src/valita.js';
-declare const ruleSchema: v.TupleType<[v.Type<"allow">, v.ObjectType<{
-    schema: v.Optional<string>;
-    table: v.Type<string>;
-    alias: v.Optional<string>;
-    where: v.Optional<{
+declare const ruleSchema: v.TupleType<[v.Type<"allow">, v.UnionType<[v.ObjectType<{
+    type: v.Type<"simple">;
+    op: v.UnionType<[v.UnionType<[v.Type<"=">, v.Type<"!=">, v.Type<"IS">, v.Type<"IS NOT">]>, v.UnionType<[v.Type<"<">, v.Type<">">, v.Type<"<=">, v.Type<">=">]>, v.UnionType<[v.Type<"LIKE">, v.Type<"NOT LIKE">, v.Type<"ILIKE">, v.Type<"NOT ILIKE">]>, v.UnionType<[v.Type<"IN">, v.Type<"NOT IN">]>]>;
+    left: v.UnionType<[v.ObjectType<{
+        type: v.Type<"literal">;
+        value: v.UnionType<[v.Type<string>, v.Type<number>, v.Type<boolean>, v.Type<null>, v.Type<readonly (string | number | boolean)[]>]>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<"column">;
+        name: v.Type<string>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<"static">;
+        anchor: v.UnionType<[v.Type<"authData">, v.Type<"preMutationRow">]>;
+        field: v.Type<string>;
+    }, undefined>]>;
+    right: v.UnionType<[v.ObjectType<{
+        type: v.Type<"static">;
+        anchor: v.UnionType<[v.Type<"authData">, v.Type<"preMutationRow">]>;
+        field: v.Type<string>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<"literal">;
+        value: v.UnionType<[v.Type<string>, v.Type<number>, v.Type<boolean>, v.Type<null>, v.Type<readonly (string | number | boolean)[]>]>;
+    }, undefined>]>;
+}, undefined>, v.Type<import("../../zero-protocol/src/ast.js").Conjunction>, v.Type<import("../../zero-protocol/src/ast.js").Disjunction>, v.ObjectType<Readonly<{
+    type: v.Type<"correlatedSubquery">;
+    related: v.Type<import("../../zero-protocol/src/ast.js").CorrelatedSubquery>;
+    op: v.UnionType<[v.Type<"EXISTS">, v.Type<"NOT EXISTS">]>;
+}>, undefined>]>]>;
+export type Rule = v.Infer<typeof ruleSchema>;
+declare const policySchema: v.ArrayType<v.TupleType<[v.Type<"allow">, v.UnionType<[v.ObjectType<{
+    type: v.Type<"simple">;
+    op: v.UnionType<[v.UnionType<[v.Type<"=">, v.Type<"!=">, v.Type<"IS">, v.Type<"IS NOT">]>, v.UnionType<[v.Type<"<">, v.Type<">">, v.Type<"<=">, v.Type<">=">]>, v.UnionType<[v.Type<"LIKE">, v.Type<"NOT LIKE">, v.Type<"ILIKE">, v.Type<"NOT ILIKE">]>, v.UnionType<[v.Type<"IN">, v.Type<"NOT IN">]>]>;
+    left: v.UnionType<[v.ObjectType<{
+        type: v.Type<"literal">;
+        value: v.UnionType<[v.Type<string>, v.Type<number>, v.Type<boolean>, v.Type<null>, v.Type<readonly (string | number | boolean)[]>]>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<"column">;
+        name: v.Type<string>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<"static">;
+        anchor: v.UnionType<[v.Type<"authData">, v.Type<"preMutationRow">]>;
+        field: v.Type<string>;
+    }, undefined>]>;
+    right: v.UnionType<[v.ObjectType<{
+        type: v.Type<"static">;
+        anchor: v.UnionType<[v.Type<"authData">, v.Type<"preMutationRow">]>;
+        field: v.Type<string>;
+    }, undefined>, v.ObjectType<{
+        type: v.Type<"literal">;
+        value: v.UnionType<[v.Type<string>, v.Type<number>, v.Type<boolean>, v.Type<null>, v.Type<readonly (string | number | boolean)[]>]>;
+    }, undefined>]>;
+}, undefined>, v.Type<import("../../zero-protocol/src/ast.js").Conjunction>, v.Type<import("../../zero-protocol/src/ast.js").Disjunction>, v.ObjectType<Readonly<{
+    type: v.Type<"correlatedSubquery">;
+    related: v.Type<import("../../zero-protocol/src/ast.js").CorrelatedSubquery>;
+    op: v.UnionType<[v.Type<"EXISTS">, v.Type<"NOT EXISTS">]>;
+}>, undefined>]>]>>;
+export type Policy = v.Infer<typeof policySchema>;
+declare const assetSchema: v.ObjectType<{
+    select: v.Optional<["allow", {
         type: "simple";
         op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
         left: {
@@ -29,21 +82,8 @@ declare const ruleSchema: v.TupleType<[v.Type<"allow">, v.ObjectType<{
         readonly type: "correlatedSubquery";
         readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
         readonly op: "EXISTS" | "NOT EXISTS";
-    }>;
-    related: v.Optional<readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[]>;
-    limit: v.Optional<number>;
-    orderBy: v.Optional<readonly (readonly [string, "asc" | "desc"])[]>;
-    start: v.Optional<{
-        row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-        exclusive: boolean;
-    }>;
-}, undefined>]>;
-export type Rule = v.Infer<typeof ruleSchema>;
-declare const policySchema: v.ArrayType<v.TupleType<[v.Type<"allow">, v.ObjectType<{
-    schema: v.Optional<string>;
-    table: v.Type<string>;
-    alias: v.Optional<string>;
-    where: v.Optional<{
+    }][]>;
+    insert: v.Optional<["allow", {
         type: "simple";
         op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
         left: {
@@ -69,21 +109,9 @@ declare const policySchema: v.ArrayType<v.TupleType<[v.Type<"allow">, v.ObjectTy
         readonly type: "correlatedSubquery";
         readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
         readonly op: "EXISTS" | "NOT EXISTS";
-    }>;
-    related: v.Optional<readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[]>;
-    limit: v.Optional<number>;
-    orderBy: v.Optional<readonly (readonly [string, "asc" | "desc"])[]>;
-    start: v.Optional<{
-        row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-        exclusive: boolean;
-    }>;
-}, undefined>]>>;
-export type Policy = v.Infer<typeof policySchema>;
-declare const assetSchema: v.ObjectType<{
-    select: v.Optional<["allow", {
-        schema?: string | undefined;
-        alias?: string | undefined;
-        where?: {
+    }][]>;
+    update: v.Optional<{
+        preMutation?: ["allow", {
             type: "simple";
             op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
             left: {
@@ -109,20 +137,8 @@ declare const assetSchema: v.ObjectType<{
             readonly type: "correlatedSubquery";
             readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
             readonly op: "EXISTS" | "NOT EXISTS";
-        } | undefined;
-        related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-        limit?: number | undefined;
-        orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-        start?: {
-            row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-            exclusive: boolean;
-        } | undefined;
-        table: string;
-    }][]>;
-    insert: v.Optional<["allow", {
-        schema?: string | undefined;
-        alias?: string | undefined;
-        where?: {
+        }][] | undefined;
+        postProposedMutation?: ["allow", {
             type: "simple";
             op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
             left: {
@@ -148,20 +164,40 @@ declare const assetSchema: v.ObjectType<{
             readonly type: "correlatedSubquery";
             readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
             readonly op: "EXISTS" | "NOT EXISTS";
-        } | undefined;
-        related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-        limit?: number | undefined;
-        orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-        start?: {
-            row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-            exclusive: boolean;
-        } | undefined;
-        table: string;
+        }][] | undefined;
+    }>;
+    delete: v.Optional<["allow", {
+        type: "simple";
+        op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+        left: {
+            type: "literal";
+            value: string | number | boolean | readonly (string | number | boolean)[] | null;
+        } | {
+            type: "column";
+            name: string;
+        } | {
+            type: "static";
+            anchor: "authData" | "preMutationRow";
+            field: string;
+        };
+        right: {
+            type: "literal";
+            value: string | number | boolean | readonly (string | number | boolean)[] | null;
+        } | {
+            type: "static";
+            anchor: "authData" | "preMutationRow";
+            field: string;
+        };
+    } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
+        readonly type: "correlatedSubquery";
+        readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
+        readonly op: "EXISTS" | "NOT EXISTS";
     }][]>;
-    update: v.Optional<["allow", {
-        schema?: string | undefined;
-        alias?: string | undefined;
-        where?: {
+}, undefined>;
+export type AssetAuthorization = v.Infer<typeof assetSchema>;
+export declare const authorizationConfigSchema: v.Type<Record<string, {
+    row?: {
+        select?: ["allow", {
             type: "simple";
             op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
             left: {
@@ -187,20 +223,8 @@ declare const assetSchema: v.ObjectType<{
             readonly type: "correlatedSubquery";
             readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
             readonly op: "EXISTS" | "NOT EXISTS";
-        } | undefined;
-        related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-        limit?: number | undefined;
-        orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-        start?: {
-            row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-            exclusive: boolean;
-        } | undefined;
-        table: string;
-    }][]>;
-    delete: v.Optional<["allow", {
-        schema?: string | undefined;
-        alias?: string | undefined;
-        where?: {
+        }][] | undefined;
+        insert?: ["allow", {
             type: "simple";
             op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
             left: {
@@ -226,63 +250,9 @@ declare const assetSchema: v.ObjectType<{
             readonly type: "correlatedSubquery";
             readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
             readonly op: "EXISTS" | "NOT EXISTS";
-        } | undefined;
-        related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-        limit?: number | undefined;
-        orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-        start?: {
-            row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-            exclusive: boolean;
-        } | undefined;
-        table: string;
-    }][]>;
-}, undefined>;
-export type AssetAuthorization = v.Infer<typeof assetSchema>;
-declare const authorizationConfigSchema: v.Type<Record<string, {
-    row?: {
-        select?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
-                type: "simple";
-                op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
-                left: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "column";
-                    name: string;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-                right: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-            } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
-                readonly type: "correlatedSubquery";
-                readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
-                readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
         }][] | undefined;
-        insert?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
+        update?: {
+            preMutation?: ["allow", {
                 type: "simple";
                 op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
                 left: {
@@ -308,20 +278,8 @@ declare const authorizationConfigSchema: v.Type<Record<string, {
                 readonly type: "correlatedSubquery";
                 readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
                 readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
-        }][] | undefined;
-        update?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
+            }][] | undefined;
+            postProposedMutation?: ["allow", {
                 type: "simple";
                 op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
                 left: {
@@ -347,139 +305,93 @@ declare const authorizationConfigSchema: v.Type<Record<string, {
                 readonly type: "correlatedSubquery";
                 readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
                 readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
-        }][] | undefined;
+            }][] | undefined;
+        } | undefined;
         delete?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
-                type: "simple";
-                op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
-                left: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "column";
-                    name: string;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-                right: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-            } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
-                readonly type: "correlatedSubquery";
-                readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
-                readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
+            type: "simple";
+            op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+            left: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "column";
+                name: string;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+            right: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+        } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
+            readonly type: "correlatedSubquery";
+            readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
+            readonly op: "EXISTS" | "NOT EXISTS";
         }][] | undefined;
     } | undefined;
     cell?: Record<string, {
         select?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
-                type: "simple";
-                op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
-                left: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "column";
-                    name: string;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-                right: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-            } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
-                readonly type: "correlatedSubquery";
-                readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
-                readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
+            type: "simple";
+            op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+            left: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "column";
+                name: string;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+            right: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+        } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
+            readonly type: "correlatedSubquery";
+            readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
+            readonly op: "EXISTS" | "NOT EXISTS";
         }][] | undefined;
         insert?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
-                type: "simple";
-                op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
-                left: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "column";
-                    name: string;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-                right: {
-                    type: "literal";
-                    value: string | number | boolean | readonly (string | number | boolean)[] | null;
-                } | {
-                    type: "static";
-                    anchor: "authData" | "preMutationRow";
-                    field: string;
-                };
-            } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
-                readonly type: "correlatedSubquery";
-                readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
-                readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
+            type: "simple";
+            op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+            left: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "column";
+                name: string;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+            right: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+        } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
+            readonly type: "correlatedSubquery";
+            readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
+            readonly op: "EXISTS" | "NOT EXISTS";
         }][] | undefined;
-        update?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
+        update?: {
+            preMutation?: ["allow", {
                 type: "simple";
                 op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
                 left: {
@@ -505,20 +417,8 @@ declare const authorizationConfigSchema: v.Type<Record<string, {
                 readonly type: "correlatedSubquery";
                 readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
                 readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
-        }][] | undefined;
-        delete?: ["allow", {
-            schema?: string | undefined;
-            alias?: string | undefined;
-            where?: {
+            }][] | undefined;
+            postProposedMutation?: ["allow", {
                 type: "simple";
                 op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
                 left: {
@@ -544,15 +444,34 @@ declare const authorizationConfigSchema: v.Type<Record<string, {
                 readonly type: "correlatedSubquery";
                 readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
                 readonly op: "EXISTS" | "NOT EXISTS";
-            } | undefined;
-            related?: readonly import("../../zero-protocol/src/ast.js").CorrelatedSubquery[] | undefined;
-            limit?: number | undefined;
-            orderBy?: readonly (readonly [string, "asc" | "desc"])[] | undefined;
-            start?: {
-                row: Record<string, import("../../shared/src/json.js").ReadonlyJSONValue | undefined>;
-                exclusive: boolean;
-            } | undefined;
-            table: string;
+            }][] | undefined;
+        } | undefined;
+        delete?: ["allow", {
+            type: "simple";
+            op: "=" | "!=" | "IS" | "IS NOT" | "<" | ">" | "<=" | ">=" | "LIKE" | "NOT LIKE" | "ILIKE" | "NOT ILIKE" | "IN" | "NOT IN";
+            left: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "column";
+                name: string;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+            right: {
+                type: "literal";
+                value: string | number | boolean | readonly (string | number | boolean)[] | null;
+            } | {
+                type: "static";
+                anchor: "authData" | "preMutationRow";
+                field: string;
+            };
+        } | import("../../zero-protocol/src/ast.js").Conjunction | import("../../zero-protocol/src/ast.js").Disjunction | {
+            readonly type: "correlatedSubquery";
+            readonly related: import("../../zero-protocol/src/ast.js").CorrelatedSubquery;
+            readonly op: "EXISTS" | "NOT EXISTS";
         }][] | undefined;
     }> | undefined;
 }>>;

package/out/zero-schema/src/compiled-authorization.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compiled-authorization.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/compiled-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAA2C,CAAC;AAC5D,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAsB,CAAC;AACzC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAKf,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE7D,QAAA,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAK9B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}
+{"version":3,"file":"compiled-authorization.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/compiled-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,QAAA,MAAM,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;kBAAiD,CAAC;AAClE,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,QAAA,MAAM,YAAY;;;;;;;;;;;;;;;;;;;;;;;;;;mBAAsB,CAAC;AACzC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,QAAA,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAUf,CAAC;AAEH,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE7D,eAAO,MAAM,yBAAyB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKrC,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,yBAAyB,CAAC,CAAC"}

package/out/zero-schema/src/compiled-authorization.js

@@ -1,14 +1,19 @@
 import * as v from '../../shared/src/valita.js';
-import { astSchema } from '../../zero-protocol/src/ast.js';
-const ruleSchema = v.tuple([v.literal('allow'), astSchema]);
+import { conditionSchema } from '../../zero-protocol/src/ast.js';
+const ruleSchema = v.tuple([v.literal('allow'), conditionSchema]);
 const policySchema = v.array(ruleSchema);
 const assetSchema = v.object({
     select: policySchema.optional(),
     insert: policySchema.optional(),
-    update: policySchema.optional(),
+    update: v
+        .object({
+        preMutation: policySchema.optional(),
+        postProposedMutation: policySchema.optional(),
+    })
+        .optional(),
     delete: policySchema.optional(),
 });
-const authorizationConfigSchema = v.record(v.object({
+export const authorizationConfigSchema = v.record(v.object({
     row: assetSchema.optional(),
     cell: v.record(assetSchema).optional(),
 }));

package/out/zero-schema/src/compiled-authorization.js.map

@@ -1 +1 @@
-{"version":3,"file":"compiled-authorization.js","sourceRoot":"","sources":["../../../../zero-schema/src/compiled-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,SAAS,EAAC,MAAM,gCAAgC,CAAC;AAEzD,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC,CAAC,CAAC;AAE5D,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;AAGzC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAIH,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CACxC,CAAC,CAAC,MAAM,CAAC;IACP,GAAG,EAAE,WAAW,CAAC,QAAQ,EAAE;IAC3B,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE;CACvC,CAAC,CACH,CAAC"}
+{"version":3,"file":"compiled-authorization.js","sourceRoot":"","sources":["../../../../zero-schema/src/compiled-authorization.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,eAAe,EAAC,MAAM,gCAAgC,CAAC;AAE/D,MAAM,UAAU,GAAG,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,eAAe,CAAC,CAAC,CAAC;AAElE,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,UAAU,CAAC,CAAC;AAGzC,MAAM,WAAW,GAAG,CAAC,CAAC,MAAM,CAAC;IAC3B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;IAC/B,MAAM,EAAE,CAAC;SACN,MAAM,CAAC;QACN,WAAW,EAAE,YAAY,CAAC,QAAQ,EAAE;QACpC,oBAAoB,EAAE,YAAY,CAAC,QAAQ,EAAE;KAC9C,CAAC;SACD,QAAQ,EAAE;IACb,MAAM,EAAE,YAAY,CAAC,QAAQ,EAAE;CAChC,CAAC,CAAC;AAIH,MAAM,CAAC,MAAM,yBAAyB,GAAG,CAAC,CAAC,MAAM,CAC/C,CAAC,CAAC,MAAM,CAAC;IACP,GAAG,EAAE,WAAW,CAAC,QAAQ,EAAE;IAC3B,IAAI,EAAE,CAAC,CAAC,MAAM,CAAC,WAAW,CAAC,CAAC,QAAQ,EAAE;CACvC,CAAC,CACH,CAAC"}