@rocicorp/zero 0.7.2024120108 → 0.7.2024120400

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

@@ -1,478 +1,36 @@
 import * as v from '../../shared/src/valita.js';
-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>]>]>;
+declare const ruleSchema: v.TupleType<[v.Type<"allow">, v.Type<import("../../zero-protocol/src/ast.js").Condition>]>;
 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>]>]>>;
+declare const policySchema: v.ArrayType<v.TupleType<[v.Type<"allow">, v.Type<import("../../zero-protocol/src/ast.js").Condition>]>>;
 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: {
-            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";
-    }][]>;
-    insert: 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";
-    }][]>;
+    select: v.Optional<["allow", import("../../zero-protocol/src/ast.js").Condition][]>;
+    insert: v.Optional<["allow", import("../../zero-protocol/src/ast.js").Condition][]>;
     update: v.Optional<{
-        preMutation?: ["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;
-        postProposedMutation?: ["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;
+        preMutation?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
+        postProposedMutation?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | 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";
-    }][]>;
+    delete: v.Optional<["allow", import("../../zero-protocol/src/ast.js").Condition][]>;
 }, undefined>;
 export type AssetPermissions = v.Infer<typeof assetSchema>;
 export declare const permissionsConfigSchema: v.Type<Record<string, {
     row?: {
-        select?: ["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;
-        insert?: ["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;
+        select?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
+        insert?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
         update?: {
-            preMutation?: ["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;
-            postProposedMutation?: ["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;
+            preMutation?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
+            postProposedMutation?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | 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;
+        delete?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
     } | undefined;
     cell?: Record<string, {
-        select?: ["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;
-        insert?: ["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;
+        select?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
+        insert?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
         update?: {
-            preMutation?: ["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;
-            postProposedMutation?: ["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;
+            preMutation?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
+            postProposedMutation?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | 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;
+        delete?: ["allow", import("../../zero-protocol/src/ast.js").Condition][] | undefined;
     }> | undefined;
 }>>;
 export type PermissionsConfig = v.Infer<typeof permissionsConfigSchema>;

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

@@ -1 +1 @@
-{"version":3,"file":"compiled-permissions.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/compiled-permissions.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,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE3D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAKnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"compiled-permissions.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/compiled-permissions.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAGhD,QAAA,MAAM,UAAU,4FAAiD,CAAC;AAClE,MAAM,MAAM,IAAI,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,UAAU,CAAC,CAAC;AAC9C,QAAA,MAAM,YAAY,yGAAsB,CAAC;AACzC,MAAM,MAAM,MAAM,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,YAAY,CAAC,CAAC;AAElD,QAAA,MAAM,WAAW;;;;;;;;aAUf,CAAC;AAEH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,WAAW,CAAC,CAAC;AAE3D,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;GAKnC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,uBAAuB,CAAC,CAAC"}

package/out/zero-schema/src/normalize-table-schema.d.ts

@@ -10,7 +10,7 @@ type Normalized<T> = T & {
  * dependencies.
  */
 export type TableSchemaCache = Map<TableSchema, NormalizedTableSchema>;
-export declare class NormalizedTableSchema {
+export declare class NormalizedTableSchema implements TableSchema {
     readonly [normalized]: true;
     readonly tableName: string;
     readonly primaryKey: NormalizedPrimaryKey;
@@ -23,7 +23,7 @@ export declare class NormalizedTableSchema {
 export declare function normalizeTableSchema(tableSchema: TableSchema | NormalizedTableSchema): NormalizedTableSchema;
 export declare function normalizeTableSchemaWithCache(tableSchema: TableSchema | NormalizedTableSchema, expectedName: string, tableSchemaCache: TableSchemaCache): NormalizedTableSchema;
 export type NormalizedPrimaryKey = Normalized<PrimaryKey>;
-export declare function normalizePrimaryKey(arr: PrimaryKey): NormalizedPrimaryKey;
+export declare function normalizePrimaryKey(primaryKey: PrimaryKey | string): NormalizedPrimaryKey;
 export type DecycledNormalizedTableSchema = Omit<NormalizedTableSchema, 'relationships'> & {
     readonly relationships: {
         readonly [relationship: string]: DecycledNormalizedFieldRelationship | readonly [
@@ -45,5 +45,6 @@ export type NormalizedJunctionRelationship = readonly [
     NormalizedFieldRelationship,
     NormalizedFieldRelationship
 ];
+export declare function normalizeTables(tables: Record<string, TableSchema>): Record<string, NormalizedTableSchema>;
 export {};
 //# sourceMappingURL=normalize-table-schema.d.ts.map

package/out/zero-schema/src/normalize-table-schema.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"normalize-table-schema.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/normalize-table-schema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wCAAwC,CAAC;AACvE,OAAO,EAIL,KAAK,WAAW,EAChB,KAAK,WAAW,EACjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,MAAM,CAAC;AAExC,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG;IAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,IAAI,CAAA;CAAC,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;AAEvE,qBAAa,qBAAqB;IAChC,SAAiB,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE;QAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAAA;KAAC,CAAC;gBAE9D,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB;CAWzE;AAED,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,WAAW,GAAG,qBAAqB,GAC/C,qBAAqB,CAMvB;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,WAAW,GAAG,qBAAqB,EAChD,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,GACjC,qBAAqB,CAmBvB;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;AAS1D,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,UAAU,GAAG,oBAAoB,CAGzE;AA+CD,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,qBAAqB,EACrB,eAAe,CAChB,GAAG;IACF,QAAQ,CAAC,aAAa,EAAE;QACtB,QAAQ,EAAE,YAAY,EAAE,MAAM,GAC1B,mCAAmC,GACnC,SAAS;YACP,mCAAmC;YACnC,mCAAmC;SACpC,CAAC;KACP,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG,IAAI,CACpD,2BAA2B,EAC3B,YAAY,CACb,GAAG;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAAC;AAElC,KAAK,sBAAsB,GACvB,2BAA2B,GAC3B,8BAA8B,CAAC;AAcnC,KAAK,2BAA2B,GAAG;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,WAAW,CAAC;IACvB,UAAU,EAAE,qBAAqB,CAAC;CACnC,CAAC;AAoBF,MAAM,MAAM,8BAA8B,GAAG,SAAS;IACpD,2BAA2B;IAC3B,2BAA2B;CAC5B,CAAC"}
+{"version":3,"file":"normalize-table-schema.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/normalize-table-schema.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAC,WAAW,EAAC,MAAM,gCAAgC,CAAC;AAChE,OAAO,KAAK,EAAC,UAAU,EAAC,MAAM,wCAAwC,CAAC;AACvE,OAAO,EAKL,KAAK,WAAW,EAChB,KAAK,WAAW,EAEjB,MAAM,mBAAmB,CAAC;AAE3B,OAAO,CAAC,MAAM,UAAU,EAAE,OAAO,MAAM,CAAC;AAExC,KAAK,UAAU,CAAC,CAAC,IAAI,CAAC,GAAG;IAAC,QAAQ,CAAC,CAAC,UAAU,CAAC,EAAE,IAAI,CAAA;CAAC,CAAC;AAEvD;;;GAGG;AACH,MAAM,MAAM,gBAAgB,GAAG,GAAG,CAAC,WAAW,EAAE,qBAAqB,CAAC,CAAC;AAEvE,qBAAa,qBAAsB,YAAW,WAAW;IACvD,SAAiB,CAAC,UAAU,CAAC,EAAE,IAAI,CAAC;IACpC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,UAAU,EAAE,oBAAoB,CAAC;IAC1C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,CAAC;IAC9C,QAAQ,CAAC,aAAa,EAAE;QAAC,QAAQ,EAAE,IAAI,EAAE,MAAM,GAAG,sBAAsB,CAAA;KAAC,CAAC;gBAE9D,WAAW,EAAE,WAAW,EAAE,gBAAgB,EAAE,gBAAgB;CAWzE;AAED,wBAAgB,oBAAoB,CAClC,WAAW,EAAE,WAAW,GAAG,qBAAqB,GAC/C,qBAAqB,CAMvB;AAED,wBAAgB,6BAA6B,CAC3C,WAAW,EAAE,WAAW,GAAG,qBAAqB,EAChD,YAAY,EAAE,MAAM,EACpB,gBAAgB,EAAE,gBAAgB,GACjC,qBAAqB,CAmBvB;AAED,MAAM,MAAM,oBAAoB,GAAG,UAAU,CAAC,UAAU,CAAC,CAAC;AAS1D,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,UAAU,GAAG,MAAM,GAC9B,oBAAoB,CAMtB;AAsDD,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,qBAAqB,EACrB,eAAe,CAChB,GAAG;IACF,QAAQ,CAAC,aAAa,EAAE;QACtB,QAAQ,EAAE,YAAY,EAAE,MAAM,GAC1B,mCAAmC,GACnC,SAAS;YACP,mCAAmC;YACnC,mCAAmC;SACpC,CAAC;KACP,CAAC;CACH,CAAC;AAEF,MAAM,MAAM,mCAAmC,GAAG,IAAI,CACpD,2BAA2B,EAC3B,YAAY,CACb,GAAG;IAAC,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAA;CAAC,CAAC;AAElC,KAAK,sBAAsB,GACvB,2BAA2B,GAC3B,8BAA8B,CAAC;AAYnC,KAAK,2BAA2B,GAAG;IACjC,WAAW,EAAE,WAAW,CAAC;IACzB,SAAS,EAAE,WAAW,CAAC;IACvB,UAAU,EAAE,qBAAqB,CAAC;CACnC,CAAC;AAsBF,MAAM,MAAM,8BAA8B,GAAG,SAAS;IACpD,2BAA2B;IAC3B,2BAA2B;CAC5B,CAAC;AAiCF,wBAAgB,eAAe,CAC7B,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,WAAW,CAAC,GAClC,MAAM,CAAC,MAAM,EAAE,qBAAqB,CAAC,CAMvC"}

package/out/zero-schema/src/normalize-table-schema.js

@@ -33,25 +33,33 @@ export function normalizeTableSchemaWithCache(tableSchema, expectedName, tableSc
 function assertNoDuplicates(arr) {
     assert(new Set(arr).size === arr.length, 'Primary key must not contain duplicates');
 }
-export function normalizePrimaryKey(arr) {
-    assertNoDuplicates(arr);
-    return arr;
+export function normalizePrimaryKey(primaryKey) {
+    if (typeof primaryKey === 'string') {
+        return [primaryKey];
+    }
+    assertNoDuplicates(primaryKey);
+    return primaryKey;
 }
 function normalizeColumns(columns, primaryKey) {
     const rv = {};
     for (const pk of primaryKey) {
         const schemaValue = columns[pk];
         assert(schemaValue, `Primary key column "${pk}" not found`);
-        const { type, optional } = schemaValue;
-        assert(!optional, `Primary key column "${pk}" cannot be optional`);
-        assert(type === 'string' || type === 'number' || type === 'boolean', `Primary key column "${pk}" must be a string, number, or boolean. Got ${type}`);
+        if (typeof schemaValue !== 'string') {
+            const { type, optional } = schemaValue;
+            assert(!optional, `Primary key column "${pk}" cannot be optional`);
+            assert(type === 'string' || type === 'number' || type === 'boolean', `Primary key column "${pk}" must be a string, number, or boolean. Got ${type}`);
+        }
     }
     for (const [name, column] of sortedEntries(columns)) {
-        rv[name] = normalizeSchemaValue(column);
+        rv[name] = normalizeColumn(column);
     }
     return rv;
 }
-function normalizeSchemaValue(value) {
+function normalizeColumn(value) {
+    if (typeof value === 'string') {
+        return { type: value, optional: false };
+    }
     return {
         type: value.type,
         optional: value.optional ?? false,
@@ -59,8 +67,10 @@ function normalizeSchemaValue(value) {
 }
 function normalizeRelationships(relationships, tableSchemaCache) {
     const rv = {};
-    for (const [name, relationship] of sortedEntries(relationships)) {
-        rv[name] = normalizeRelationship(relationship, tableSchemaCache);
+    if (relationships) {
+        for (const [name, relationship] of sortedEntries(relationships)) {
+            rv[name] = normalizeRelationship(relationship, tableSchemaCache);
+        }
     }
     return rv;
 }
@@ -71,10 +81,12 @@ function normalizeRelationship(relationship, tableSchemaCache) {
     return normalizeJunctionRelationship(relationship, tableSchemaCache);
 }
 function normalizeFieldRelationship(relationship, tableSchemaCache) {
-    assert(relationship.sourceField.length === relationship.destField.length, 'Source and destination fields must have the same length');
+    const sourceField = normalizeFieldName(relationship.sourceField);
+    const destField = normalizeFieldName(relationship.destField);
+    assert(sourceField.length === destField.length, 'Source and destination fields must have the same length');
     return {
-        sourceField: relationship.sourceField,
-        destField: relationship.destField,
+        sourceField,
+        destField,
         destSchema: normalizeLazyTableSchema(relationship.destSchema, tableSchemaCache),
     };
 }
@@ -89,4 +101,18 @@ function normalizeLazyTableSchema(tableSchema, buildCache) {
     return normalizeTableSchemaWithCache(tableSchemaInstance, tableSchemaInstance.tableName, // Don't care about name here.
     buildCache);
 }
+function normalizeFieldName(sourceField) {
+    if (typeof sourceField === 'string') {
+        return [sourceField];
+    }
+    assert(sourceField.length > 0, 'Expected at least one field');
+    return sourceField;
+}
+export function normalizeTables(tables) {
+    const result = {};
+    for (const [name, table] of sortedEntries(tables)) {
+        result[name] = normalizeTableSchemaWithCache(table, name, new Map());
+    }
+    return result;
+}
 //# sourceMappingURL=normalize-table-schema.js.map