@rocicorp/zero 0.6.2024112102 → 0.7.2024120100

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

@@ -27,10 +27,14 @@ export declare const pokeStartBodySchema: v.ObjectType<{
     pokeID: v.Type<string>;
     baseCookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
     cookie: v.Type<string>;
-    schemaVersions: v.ObjectType<{
-        minSupportedVersion: v.Type<number>;
-        maxSupportedVersion: v.Type<number>;
-    }, undefined>;
+    /**
+     * This field is always set if the poke contains a `rowsPatch`.
+     * It may be absent for patches that only update clients and queries.
+     */
+    schemaVersions: v.Optional<{
+        minSupportedVersion: number;
+        maxSupportedVersion: number;
+    }>;
     timestamp: v.Optional<number>;
 }, undefined>;
 export declare const pokePartBodySchema: v.ObjectType<{
@@ -167,10 +171,14 @@ export declare const pokeStartMessageSchema: v.TupleType<[v.Type<"pokeStart">, v
     pokeID: v.Type<string>;
     baseCookie: v.UnionType<[v.Type<string>, v.Type<null>]>;
     cookie: v.Type<string>;
-    schemaVersions: v.ObjectType<{
-        minSupportedVersion: v.Type<number>;
-        maxSupportedVersion: v.Type<number>;
-    }, undefined>;
+    /**
+     * This field is always set if the poke contains a `rowsPatch`.
+     * It may be absent for patches that only update clients and queries.
+     */
+    schemaVersions: v.Optional<{
+        minSupportedVersion: number;
+        maxSupportedVersion: number;
+    }>;
     timestamp: v.Optional<number>;
 }, undefined>]>;
 export declare const pokePartMessageSchema: v.TupleType<[v.Type<"pokePart">, v.ObjectType<{

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

@@ -1 +1 @@
-{"version":3,"file":"poke.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,mBAAmB;;;;;;;;;aAY9B,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;aAK5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;;;;;;eAGjC,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAGhC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;eAG/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}
+{"version":3,"file":"poke.d.ts","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAMhD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,eAAO,MAAM,mBAAmB;;;;IAO9B;;;OAGG;;;;;;aAQH,CAAC;AAEH,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;aAc7B,CAAC;AAEH,eAAO,MAAM,iBAAiB;;;aAK5B,CAAC;AAEH,eAAO,MAAM,sBAAsB;;;;IApCjC;;;OAGG;;;;;;eAoCH,CAAC;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;eAGhC,CAAC;AACH,eAAO,MAAM,oBAAoB;;;eAG/B,CAAC;AAEH,MAAM,MAAM,aAAa,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAC;AAChE,MAAM,MAAM,YAAY,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAC;AAC9D,MAAM,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,iBAAiB,CAAC,CAAC;AAE5D,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,sBAAsB,CAAC,CAAC;AACtE,MAAM,MAAM,eAAe,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,qBAAqB,CAAC,CAAC;AACpE,MAAM,MAAM,cAAc,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,oBAAoB,CAAC,CAAC"}

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

@@ -34,10 +34,16 @@ export const pokeStartBodySchema = v.object({
     // able to send a base cookie with value `null` to match that state.
     baseCookie: nullableVersionSchema,
     cookie: versionSchema,
-    schemaVersions: v.object({
+    /**
+     * This field is always set if the poke contains a `rowsPatch`.
+     * It may be absent for patches that only update clients and queries.
+     */
+    schemaVersions: v
+        .object({
         minSupportedVersion: v.number(),
         maxSupportedVersion: v.number(),
-    }),
+    })
+        .optional(),
     timestamp: v.number().optional(),
 });
 export const pokePartBodySchema = v.object({

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

@@ -1 +1 @@
-{"version":3,"file":"poke.js","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,cAAc,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,2EAA2E;IAC3E,yEAAyE;IACzE,oEAAoE;IACpE,UAAU,EAAE,qBAAqB;IACjC,MAAM,EAAE,aAAa;IACrB,cAAc,EAAE,CAAC,CAAC,MAAM,CAAC;QACvB,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC/B,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE;KAChC,CAAC;IACF,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,4CAA4C;IAC5C,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACtD,2EAA2E;IAC3E,qBAAqB;IACrB,YAAY,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,kDAAkD;IAClD,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE;IAC9D,iEAAiE;IACjE,aAAa;IACb,eAAe,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC9C,2BAA2B;IAC3B,SAAS,EAAE,eAAe,CAAC,QAAQ,EAAE;CACtC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,mEAAmE;IACnE,eAAe;IACf,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC5C,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IACtB,mBAAmB;CACpB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC3C,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;IACrB,kBAAkB;CACnB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC1C,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACpB,iBAAiB;CAClB,CAAC,CAAC"}
+{"version":3,"file":"poke.js","sourceRoot":"","sources":["../../../../zero-protocol/src/poke.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,kBAAkB,EAAC,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAC,eAAe,EAAC,MAAM,gBAAgB,CAAC;AAC/C,OAAO,EAAC,qBAAqB,EAAE,aAAa,EAAC,MAAM,cAAc,CAAC;AAElE;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,CAAC,MAAM,CAAC;IAC1C,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,2EAA2E;IAC3E,yEAAyE;IACzE,oEAAoE;IACpE,UAAU,EAAE,qBAAqB;IACjC,MAAM,EAAE,aAAa;IACrB;;;OAGG;IACH,cAAc,EAAE,CAAC;SACd,MAAM,CAAC;QACN,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE;QAC/B,mBAAmB,EAAE,CAAC,CAAC,MAAM,EAAE;KAChC,CAAC;SACD,QAAQ,EAAE;IACb,SAAS,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,QAAQ,EAAE;CACjC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,kBAAkB,GAAG,CAAC,CAAC,MAAM,CAAC;IACzC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,4CAA4C;IAC5C,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC,QAAQ,EAAE;IACtD,2EAA2E;IAC3E,qBAAqB;IACrB,YAAY,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC3C,kDAAkD;IAClD,qBAAqB,EAAE,CAAC,CAAC,MAAM,CAAC,kBAAkB,CAAC,CAAC,QAAQ,EAAE;IAC9D,iEAAiE;IACjE,aAAa;IACb,eAAe,EAAE,kBAAkB,CAAC,QAAQ,EAAE;IAC9C,2BAA2B;IAC3B,SAAS,EAAE,eAAe,CAAC,QAAQ,EAAE;CACtC,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,iBAAiB,GAAG,CAAC,CAAC,MAAM,CAAC;IACxC,MAAM,EAAE,CAAC,CAAC,MAAM,EAAE;IAClB,mEAAmE;IACnE,eAAe;IACf,MAAM,EAAE,CAAC,CAAC,OAAO,EAAE,CAAC,QAAQ,EAAE;CAC/B,CAAC,CAAC;AAEH,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC5C,CAAC,CAAC,OAAO,CAAC,WAAW,CAAC;IACtB,mBAAmB;CACpB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC3C,CAAC,CAAC,OAAO,CAAC,UAAU,CAAC;IACrB,kBAAkB;CACnB,CAAC,CAAC;AACH,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,CAAC,KAAK,CAAC;IAC1C,CAAC,CAAC,OAAO,CAAC,SAAS,CAAC;IACpB,iBAAiB;CAClB,CAAC,CAAC"}

package/out/zero-schema/src/build-schema.d.ts

@@ -0,0 +1,14 @@
+import * as v from '../../shared/src/valita.js';
+export declare const schemaOptions: {
+    path: {
+        type: v.Type<string>;
+        desc: string[];
+        alias: string;
+    };
+    output: {
+        type: v.Type<string>;
+        desc: string[];
+        alias: string;
+    };
+};
+//# sourceMappingURL=build-schema.d.ts.map

package/out/zero-schema/src/build-schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-schema.d.ts","sourceRoot":"","sources":["../../../../zero-schema/src/build-schema.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAQhD,eAAO,MAAM,aAAa;;;;;;;;;;;CAmBzB,CAAC"}

package/out/zero-schema/src/build-schema.js

@@ -0,0 +1,55 @@
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { tsImport } from 'tsx/esm/api';
+import { writeFile } from 'node:fs/promises';
+import { permissionsConfigSchema } from './compiled-permissions.js';
+import * as v from '../../shared/src/valita.js';
+import { parseOptions } from '../../shared/src/options.js';
+import { normalizeSchema } from './normalized-schema.js';
+import { isSchemaConfig, replacePointersWithSchemaNames, } from './schema-config.js';
+export const schemaOptions = {
+    path: {
+        type: v.string().default('schema.ts'),
+        desc: [
+            'Relative path to the file containing the schema definition.',
+            'The file must have a default export of type SchemaConfig.',
+        ],
+        alias: 'p',
+    },
+    output: {
+        type: v.string().default('zero-schema.json'),
+        desc: [
+            'Output path for the generated schema JSON file.',
+            '',
+            'The schema will be written as a JSON file containing the compiled',
+            'permission rules derived from your schema definition.',
+        ],
+        alias: 'o',
+    },
+};
+async function main() {
+    const config = parseOptions(schemaOptions, process.argv.slice(2), 'ZERO_SCHEMA_');
+    const dirname = path.dirname(fileURLToPath(import.meta.url));
+    const absoluteConfigPath = path.resolve(config.path);
+    const relativePath = path.join(path.relative(dirname, path.dirname(absoluteConfigPath)), path.basename(absoluteConfigPath));
+    try {
+        const module = await tsImport(relativePath, import.meta.url);
+        if (!isSchemaConfig(module)) {
+            throw new Error('Schema file must have a export `schema` and `permissions`.');
+        }
+        const schemaConfig = module;
+        const permissions = v.parse(await schemaConfig.permissions, permissionsConfigSchema);
+        const cycleFreeNormalizedSchema = replacePointersWithSchemaNames(normalizeSchema(schemaConfig.schema));
+        const output = {
+            permissions,
+            schema: cycleFreeNormalizedSchema,
+        };
+        await writeFile(config.output, JSON.stringify(output, undefined, 2));
+    }
+    catch (e) {
+        console.error(`Failed to load zero schema from ${absoluteConfigPath}:`, e);
+        process.exit(1);
+    }
+}
+void main();
+//# sourceMappingURL=build-schema.js.map

package/out/zero-schema/src/build-schema.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-schema.js","sourceRoot":"","sources":["../../../../zero-schema/src/build-schema.ts"],"names":[],"mappings":"AAAA,OAAO,IAAI,MAAM,WAAW,CAAC;AAC7B,OAAO,EAAC,aAAa,EAAC,MAAM,UAAU,CAAC;AACvC,OAAO,EAAC,QAAQ,EAAC,MAAM,aAAa,CAAC;AACrC,OAAO,EAAC,SAAS,EAAC,MAAM,kBAAkB,CAAC;AAC3C,OAAO,EAAC,uBAAuB,EAAC,MAAM,2BAA2B,CAAC;AAClE,OAAO,KAAK,CAAC,MAAM,4BAA4B,CAAC;AAChD,OAAO,EAAC,YAAY,EAAC,MAAM,6BAA6B,CAAC;AACzD,OAAO,EAAC,eAAe,EAAC,MAAM,wBAAwB,CAAC;AACvD,OAAO,EACL,cAAc,EACd,8BAA8B,GAC/B,MAAM,oBAAoB,CAAC;AAE5B,MAAM,CAAC,MAAM,aAAa,GAAG;IAC3B,IAAI,EAAE;QACJ,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC;QACrC,IAAI,EAAE;YACJ,6DAA6D;YAC7D,2DAA2D;SAC5D;QACD,KAAK,EAAE,GAAG;KACX;IACD,MAAM,EAAE;QACN,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC,OAAO,CAAC,kBAAkB,CAAC;QAC5C,IAAI,EAAE;YACJ,iDAAiD;YACjD,EAAE;YACF,mEAAmE;YACnE,uDAAuD;SACxD;QACD,KAAK,EAAE,GAAG;KACX;CACF,CAAC;AAEF,KAAK,UAAU,IAAI;IACjB,MAAM,MAAM,GAAG,YAAY,CACzB,aAAa,EACb,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EACrB,cAAc,CACf,CAAC;IAEF,MAAM,OAAO,GAAG,IAAI,CAAC,OAAO,CAAC,aAAa,CAAC,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAC7D,MAAM,kBAAkB,GAAG,IAAI,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC,CAAC;IACrD,MAAM,YAAY,GAAG,IAAI,CAAC,IAAI,CAC5B,IAAI,CAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,EACxD,IAAI,CAAC,QAAQ,CAAC,kBAAkB,CAAC,CAClC,CAAC;IAEF,IAAI,CAAC;QACH,MAAM,MAAM,GAAG,MAAM,QAAQ,CAAC,YAAY,EAAE,MAAM,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC;QAC7D,IAAI,CAAC,cAAc,CAAC,MAAM,CAAC,EAAE,CAAC;YAC5B,MAAM,IAAI,KAAK,CACb,4DAA4D,CAC7D,CAAC;QACJ,CAAC;QACD,MAAM,YAAY,GAAG,MAAM,CAAC;QAC5B,MAAM,WAAW,GAAG,CAAC,CAAC,KAAK,CACzB,MAAM,YAAY,CAAC,WAAW,EAC9B,uBAAuB,CACxB,CAAC;QAEF,MAAM,yBAAyB,GAAG,8BAA8B,CAC9D,eAAe,CAAC,YAAY,CAAC,MAAM,CAAC,CACrC,CAAC;QAEF,MAAM,MAAM,GAAG;YACb,WAAW;YACX,MAAM,EAAE,yBAAyB;SAClC,CAAC;QAEF,MAAM,SAAS,CAAC,MAAM,CAAC,MAAM,EAAE,IAAI,CAAC,SAAS,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC,CAAC,CAAC,CAAC;IACvE,CAAC;IAAC,OAAO,CAAC,EAAE,CAAC;QACX,OAAO,CAAC,KAAK,CAAC,mCAAmC,kBAAkB,GAAG,EAAE,CAAC,CAAC,CAAC;QAC3E,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;IAClB,CAAC;AACH,CAAC;AAED,KAAK,IAAI,EAAE,CAAC"}

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

@@ -0,0 +1,480 @@
+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>]>]>;
+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: {
+            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";
+    }][]>;
+    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;
+    }>;
+    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";
+    }][]>;
+}, 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;
+        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;
+        } | 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;
+    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;
+        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;
+        } | 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;
+}>>;
+export type PermissionsConfig = v.Infer<typeof permissionsConfigSchema>;
+export {};
+//# sourceMappingURL=compiled-permissions.d.ts.map

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

@@ -0,0 +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"}