@zanzojs/drizzle 0.1.0-beta.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Gonzalo Jeria
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.cjs

@@ -0,0 +1,66 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  createZanzoAdapter: () => createZanzoAdapter
+});
+module.exports = __toCommonJS(index_exports);
+var import_drizzle_orm = require("drizzle-orm");
+var import_core = require("@zanzojs/core");
+function createZanzoAdapter(engine, tupleTable, options) {
+  const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+  const shouldWarn = options?.warnOnNestedConditions ?? isDev;
+  return function withPermissions(actor, action, resourceType, resourceIdColumn) {
+    const ast = engine.buildDatabaseQuery(actor, action, resourceType);
+    if (ast && ast.conditions.length > 100) {
+      throw new Error(`[Zanzo] Security Exception: The resulting AST exceeds the maximum safe limit of 100 conditional branches. Please optimize your schema or rely on pre-computed tuples to avoid database exhaustion.`);
+    }
+    if (!ast) {
+      return import_drizzle_orm.sql`1 = 0`;
+    }
+    const parseCondition = (cond) => {
+      const objectString = import_drizzle_orm.sql`${resourceType} || '${import_drizzle_orm.sql.raw(import_core.ENTITY_REF_SEPARATOR)}' || ${resourceIdColumn}`;
+      if (cond.type === "nested" && shouldWarn) {
+        console.warn(`[Zanzo] Nested permission path detected: '${[cond.relation, ...cond.nextRelationPath].join(import_core.RELATION_PATH_SEPARATOR)}'. The SQL adapter resolves this via pre-materialized tuples. Ensure you used expandTuples() when writing this relationship to the database. See: https://zanzo.dev/docs/tuple-expansion`);
+      }
+      const relationString = cond.type === "nested" ? [cond.relation, ...cond.nextRelationPath].join(import_core.RELATION_PATH_SEPARATOR) : cond.relation;
+      return import_drizzle_orm.sql`EXISTS (
+        SELECT 1 FROM ${tupleTable} 
+        WHERE ${tupleTable.object} = ${objectString} 
+          AND ${tupleTable.relation} = ${relationString} 
+          AND ${tupleTable.subject} = ${cond.targetSubject}
+      )`;
+    };
+    const parsedConditions = ast.conditions.map(parseCondition).filter((c) => c !== void 0);
+    if (parsedConditions.length === 0) {
+      return import_drizzle_orm.sql`1 = 0`;
+    }
+    if (ast.operator === "AND") {
+      return (0, import_drizzle_orm.and)(...parsedConditions);
+    }
+    return (0, import_drizzle_orm.or)(...parsedConditions);
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  createZanzoAdapter
+});
+//# sourceMappingURL=index.cjs.map

package/dist/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { or, and, SQL, sql, AnyColumn } from 'drizzle-orm';\nimport type { QueryAST, Condition, ZanzoEngine, SchemaData, ExtractSchemaResources, ExtractSchemaActions } from '@zanzojs/core';\nimport { ENTITY_REF_SEPARATOR, RELATION_PATH_SEPARATOR } from '@zanzojs/core';\n\n/**\n * Ensures the passed Drizzle Table conforms to the mandatory Zanzibar Universal Tuple Structure.\n */\nexport interface ZanzoTupleTable {\n  object: AnyColumn; // String e.g. \"Invoice:123\"\n  relation: AnyColumn; // String e.g. \"owner\"\n  subject: AnyColumn;  // String e.g. \"User:1\"\n  [key: string]: any; // Allow extensions like IDs or context\n}\n\nexport interface ZanzoAdapterOptions {\n  /**\n   * Emits a console.warn when a nested permission path (e.g. 'org.admin') is detected,\n   * reminding you to use expandTuples() when writing this relationship.\n   *\n   * @default true in NODE_ENV=development, false in production\n   */\n  warnOnNestedConditions?: boolean;\n}\n\n/**\n * Creates a \"Zero-Config\" Drizzle ORM permission adapter tailored for the Zanzibar Pattern.\n * Rather than mapping individual specific columns, this queries a Universal Tuple Table resolving access instantly.\n *\n * @param engine The initialized ZanzoEngine instance\n * @param tupleTable The central Drizzle Table where all Relation Tuples are stored\n * @param options Optional configuration for the adapter\n * @returns A bounded `withPermissions` closure\n */\nexport function createZanzoAdapter<TSchema extends SchemaData, TTable extends ZanzoTupleTable>(\n  engine: ZanzoEngine<TSchema>,\n  tupleTable: TTable,\n  options?: ZanzoAdapterOptions\n) {\n  // Smart default: auto-enable warnings in development unless explicitly configured\n  const isDev = typeof process !== 'undefined' && process.env?.NODE_ENV === 'development';\n  const shouldWarn = options?.warnOnNestedConditions ?? isDev;\n\n  /**\n   * Generates a Drizzle SQL AST (subquery strategy) resolving access against the Universal Tuple Table.\n   *\n   * @param actor The Subject identifier validating access (e.g \"User:1\")\n   * @param action The protected action (e.g \"read\")\n   * @param resourceType The target Domain scope (e.g \"Invoice\")\n   * @param resourceIdColumn The specific Drizzle column representing the object's ID in the business table (e.g `invoices.id`)\n   */\n  return function withPermissions<\n    TResourceName extends Extract<ExtractSchemaResources<TSchema>, string>,\n    TAction extends ExtractSchemaActions<TSchema, TResourceName>,\n  >(\n    actor: string,\n    action: TAction,\n    resourceType: TResourceName,\n    resourceIdColumn: AnyColumn\n  ): SQL<unknown> {\n    \n    // Evaluate the underlying pure logical AST\n    const ast = engine.buildDatabaseQuery(actor, action as any, resourceType as any);\n\n    // Protection Against 'The List Problem' / Query Payload Exhaustion:\n    // If a badly designed ReBAC schema generates a monstrous combinatorial AST tree, \n    // it could exceed max SQL text limits resulting in DB crashes. Abort safely.\n    if (ast && ast.conditions.length > 100) {\n      throw new Error(`[Zanzo] Security Exception: The resulting AST exceeds the maximum safe limit of 100 conditional branches. Please optimize your schema or rely on pre-computed tuples to avoid database exhaustion.`);\n    }\n\n    if (!ast) {\n      // Access totally denied\n      return sql`1 = 0`; \n    }\n\n    const parseCondition = (cond: Condition): SQL<unknown> | undefined => {\n      \n      // In the Zanzibar Pattern, ALL conditions (direct or nested) ultimately result\n      // in looking up pre-computed or dynamically queried tuples.\n      // E.g for a direct target: SELECT 1 FROM tuples WHERE object = TYPE:ID AND relation = X AND subject = TARGET\n      \n      const objectString = sql`${resourceType} || '${sql.raw(ENTITY_REF_SEPARATOR)}' || ${resourceIdColumn}`;\n\n      // In Zanzibar, nested conditions (e.g. org.admin) are evaluated using the \"Tuple Expansion\" pattern.\n      // This means the user has asynchronously written materialized tuples into the database.\n      // Therefore, both direct and nested queries are resolved identically via O(1) EXISTS lookups.\n      if (cond.type === 'nested' && shouldWarn) {\n        console.warn(`[Zanzo] Nested permission path detected: '${[cond.relation, ...cond.nextRelationPath].join(RELATION_PATH_SEPARATOR)}'. The SQL adapter resolves this via pre-materialized tuples. Ensure you used expandTuples() when writing this relationship to the database. See: https://zanzo.dev/docs/tuple-expansion`);\n      }\n\n      const relationString = cond.type === 'nested' \n        ? [cond.relation, ...cond.nextRelationPath].join(RELATION_PATH_SEPARATOR) \n        : cond.relation;\n\n      return sql`EXISTS (\n        SELECT 1 FROM ${tupleTable} \n        WHERE ${tupleTable.object} = ${objectString} \n          AND ${tupleTable.relation} = ${relationString} \n          AND ${tupleTable.subject} = ${cond.targetSubject}\n      )`;\n    };\n\n    const parsedConditions = ast.conditions\n      .map(parseCondition)\n      .filter((c): c is SQL<unknown> => c !== undefined);\n\n    if (parsedConditions.length === 0) {\n       return sql`1 = 0`;\n    }\n\n    if (ast.operator === 'AND') {\n      return and(...parsedConditions) as SQL<unknown>;\n    }\n\n    return or(...parsedConditions) as SQL<unknown>;\n  };\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,yBAA6C;AAE7C,kBAA8D;AA+BvD,SAAS,mBACd,QACA,YACA,SACA;AAEA,QAAM,QAAQ,OAAO,YAAY,eAAe,QAAQ,KAAK,aAAa;AAC1E,QAAM,aAAa,SAAS,0BAA0B;AAUtD,SAAO,SAAS,gBAId,OACA,QACA,cACA,kBACc;AAGd,UAAM,MAAM,OAAO,mBAAmB,OAAO,QAAe,YAAmB;AAK/E,QAAI,OAAO,IAAI,WAAW,SAAS,KAAK;AACtC,YAAM,IAAI,MAAM,oMAAoM;AAAA,IACtN;AAEA,QAAI,CAAC,KAAK;AAER,aAAO;AAAA,IACT;AAEA,UAAM,iBAAiB,CAAC,SAA8C;AAMpE,YAAM,eAAe,yBAAM,YAAY,QAAQ,uBAAI,IAAI,gCAAoB,CAAC,QAAQ,gBAAgB;AAKpG,UAAI,KAAK,SAAS,YAAY,YAAY;AACxC,gBAAQ,KAAK,6CAA6C,CAAC,KAAK,UAAU,GAAG,KAAK,gBAAgB,EAAE,KAAK,mCAAuB,CAAC,0LAA0L;AAAA,MAC7T;AAEA,YAAM,iBAAiB,KAAK,SAAS,WACjC,CAAC,KAAK,UAAU,GAAG,KAAK,gBAAgB,EAAE,KAAK,mCAAuB,IACtE,KAAK;AAET,aAAO;AAAA,wBACW,UAAU;AAAA,gBAClB,WAAW,MAAM,MAAM,YAAY;AAAA,gBACnC,WAAW,QAAQ,MAAM,cAAc;AAAA,gBACvC,WAAW,OAAO,MAAM,KAAK,aAAa;AAAA;AAAA,IAEtD;AAEA,UAAM,mBAAmB,IAAI,WAC1B,IAAI,cAAc,EAClB,OAAO,CAAC,MAAyB,MAAM,MAAS;AAEnD,QAAI,iBAAiB,WAAW,GAAG;AAChC,aAAO;AAAA,IACV;AAEA,QAAI,IAAI,aAAa,OAAO;AAC1B,iBAAO,wBAAI,GAAG,gBAAgB;AAAA,IAChC;AAEA,eAAO,uBAAG,GAAG,gBAAgB;AAAA,EAC/B;AACF;","names":[]}

package/dist/index.d.cts

@@ -0,0 +1,33 @@
+import { AnyColumn, SQL } from 'drizzle-orm';
+import { SchemaData, ZanzoEngine, ExtractSchemaResources, ExtractSchemaActions } from '@zanzojs/core';
+
+/**
+ * Ensures the passed Drizzle Table conforms to the mandatory Zanzibar Universal Tuple Structure.
+ */
+interface ZanzoTupleTable {
+    object: AnyColumn;
+    relation: AnyColumn;
+    subject: AnyColumn;
+    [key: string]: any;
+}
+interface ZanzoAdapterOptions {
+    /**
+     * Emits a console.warn when a nested permission path (e.g. 'org.admin') is detected,
+     * reminding you to use expandTuples() when writing this relationship.
+     *
+     * @default true in NODE_ENV=development, false in production
+     */
+    warnOnNestedConditions?: boolean;
+}
+/**
+ * Creates a "Zero-Config" Drizzle ORM permission adapter tailored for the Zanzibar Pattern.
+ * Rather than mapping individual specific columns, this queries a Universal Tuple Table resolving access instantly.
+ *
+ * @param engine The initialized ZanzoEngine instance
+ * @param tupleTable The central Drizzle Table where all Relation Tuples are stored
+ * @param options Optional configuration for the adapter
+ * @returns A bounded `withPermissions` closure
+ */
+declare function createZanzoAdapter<TSchema extends SchemaData, TTable extends ZanzoTupleTable>(engine: ZanzoEngine<TSchema>, tupleTable: TTable, options?: ZanzoAdapterOptions): <TResourceName extends Extract<ExtractSchemaResources<TSchema>, string>, TAction extends ExtractSchemaActions<TSchema, TResourceName>>(actor: string, action: TAction, resourceType: TResourceName, resourceIdColumn: AnyColumn) => SQL<unknown>;
+
+export { type ZanzoAdapterOptions, type ZanzoTupleTable, createZanzoAdapter };

package/dist/index.d.ts

@@ -0,0 +1,33 @@
+import { AnyColumn, SQL } from 'drizzle-orm';
+import { SchemaData, ZanzoEngine, ExtractSchemaResources, ExtractSchemaActions } from '@zanzojs/core';
+
+/**
+ * Ensures the passed Drizzle Table conforms to the mandatory Zanzibar Universal Tuple Structure.
+ */
+interface ZanzoTupleTable {
+    object: AnyColumn;
+    relation: AnyColumn;
+    subject: AnyColumn;
+    [key: string]: any;
+}
+interface ZanzoAdapterOptions {
+    /**
+     * Emits a console.warn when a nested permission path (e.g. 'org.admin') is detected,
+     * reminding you to use expandTuples() when writing this relationship.
+     *
+     * @default true in NODE_ENV=development, false in production
+     */
+    warnOnNestedConditions?: boolean;
+}
+/**
+ * Creates a "Zero-Config" Drizzle ORM permission adapter tailored for the Zanzibar Pattern.
+ * Rather than mapping individual specific columns, this queries a Universal Tuple Table resolving access instantly.
+ *
+ * @param engine The initialized ZanzoEngine instance
+ * @param tupleTable The central Drizzle Table where all Relation Tuples are stored
+ * @param options Optional configuration for the adapter
+ * @returns A bounded `withPermissions` closure
+ */
+declare function createZanzoAdapter<TSchema extends SchemaData, TTable extends ZanzoTupleTable>(engine: ZanzoEngine<TSchema>, tupleTable: TTable, options?: ZanzoAdapterOptions): <TResourceName extends Extract<ExtractSchemaResources<TSchema>, string>, TAction extends ExtractSchemaActions<TSchema, TResourceName>>(actor: string, action: TAction, resourceType: TResourceName, resourceIdColumn: AnyColumn) => SQL<unknown>;
+
+export { type ZanzoAdapterOptions, type ZanzoTupleTable, createZanzoAdapter };

package/dist/index.js

@@ -0,0 +1,41 @@
+// src/index.ts
+import { or, and, sql } from "drizzle-orm";
+import { ENTITY_REF_SEPARATOR, RELATION_PATH_SEPARATOR } from "@zanzojs/core";
+function createZanzoAdapter(engine, tupleTable, options) {
+  const isDev = typeof process !== "undefined" && process.env?.NODE_ENV === "development";
+  const shouldWarn = options?.warnOnNestedConditions ?? isDev;
+  return function withPermissions(actor, action, resourceType, resourceIdColumn) {
+    const ast = engine.buildDatabaseQuery(actor, action, resourceType);
+    if (ast && ast.conditions.length > 100) {
+      throw new Error(`[Zanzo] Security Exception: The resulting AST exceeds the maximum safe limit of 100 conditional branches. Please optimize your schema or rely on pre-computed tuples to avoid database exhaustion.`);
+    }
+    if (!ast) {
+      return sql`1 = 0`;
+    }
+    const parseCondition = (cond) => {
+      const objectString = sql`${resourceType} || '${sql.raw(ENTITY_REF_SEPARATOR)}' || ${resourceIdColumn}`;
+      if (cond.type === "nested" && shouldWarn) {
+        console.warn(`[Zanzo] Nested permission path detected: '${[cond.relation, ...cond.nextRelationPath].join(RELATION_PATH_SEPARATOR)}'. The SQL adapter resolves this via pre-materialized tuples. Ensure you used expandTuples() when writing this relationship to the database. See: https://zanzo.dev/docs/tuple-expansion`);
+      }
+      const relationString = cond.type === "nested" ? [cond.relation, ...cond.nextRelationPath].join(RELATION_PATH_SEPARATOR) : cond.relation;
+      return sql`EXISTS (
+        SELECT 1 FROM ${tupleTable} 
+        WHERE ${tupleTable.object} = ${objectString} 
+          AND ${tupleTable.relation} = ${relationString} 
+          AND ${tupleTable.subject} = ${cond.targetSubject}
+      )`;
+    };
+    const parsedConditions = ast.conditions.map(parseCondition).filter((c) => c !== void 0);
+    if (parsedConditions.length === 0) {
+      return sql`1 = 0`;
+    }
+    if (ast.operator === "AND") {
+      return and(...parsedConditions);
+    }
+    return or(...parsedConditions);
+  };
+}
+export {
+  createZanzoAdapter
+};
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/index.ts"],"sourcesContent":["import { or, and, SQL, sql, AnyColumn } from 'drizzle-orm';\nimport type { QueryAST, Condition, ZanzoEngine, SchemaData, ExtractSchemaResources, ExtractSchemaActions } from '@zanzojs/core';\nimport { ENTITY_REF_SEPARATOR, RELATION_PATH_SEPARATOR } from '@zanzojs/core';\n\n/**\n * Ensures the passed Drizzle Table conforms to the mandatory Zanzibar Universal Tuple Structure.\n */\nexport interface ZanzoTupleTable {\n  object: AnyColumn; // String e.g. \"Invoice:123\"\n  relation: AnyColumn; // String e.g. \"owner\"\n  subject: AnyColumn;  // String e.g. \"User:1\"\n  [key: string]: any; // Allow extensions like IDs or context\n}\n\nexport interface ZanzoAdapterOptions {\n  /**\n   * Emits a console.warn when a nested permission path (e.g. 'org.admin') is detected,\n   * reminding you to use expandTuples() when writing this relationship.\n   *\n   * @default true in NODE_ENV=development, false in production\n   */\n  warnOnNestedConditions?: boolean;\n}\n\n/**\n * Creates a \"Zero-Config\" Drizzle ORM permission adapter tailored for the Zanzibar Pattern.\n * Rather than mapping individual specific columns, this queries a Universal Tuple Table resolving access instantly.\n *\n * @param engine The initialized ZanzoEngine instance\n * @param tupleTable The central Drizzle Table where all Relation Tuples are stored\n * @param options Optional configuration for the adapter\n * @returns A bounded `withPermissions` closure\n */\nexport function createZanzoAdapter<TSchema extends SchemaData, TTable extends ZanzoTupleTable>(\n  engine: ZanzoEngine<TSchema>,\n  tupleTable: TTable,\n  options?: ZanzoAdapterOptions\n) {\n  // Smart default: auto-enable warnings in development unless explicitly configured\n  const isDev = typeof process !== 'undefined' && process.env?.NODE_ENV === 'development';\n  const shouldWarn = options?.warnOnNestedConditions ?? isDev;\n\n  /**\n   * Generates a Drizzle SQL AST (subquery strategy) resolving access against the Universal Tuple Table.\n   *\n   * @param actor The Subject identifier validating access (e.g \"User:1\")\n   * @param action The protected action (e.g \"read\")\n   * @param resourceType The target Domain scope (e.g \"Invoice\")\n   * @param resourceIdColumn The specific Drizzle column representing the object's ID in the business table (e.g `invoices.id`)\n   */\n  return function withPermissions<\n    TResourceName extends Extract<ExtractSchemaResources<TSchema>, string>,\n    TAction extends ExtractSchemaActions<TSchema, TResourceName>,\n  >(\n    actor: string,\n    action: TAction,\n    resourceType: TResourceName,\n    resourceIdColumn: AnyColumn\n  ): SQL<unknown> {\n    \n    // Evaluate the underlying pure logical AST\n    const ast = engine.buildDatabaseQuery(actor, action as any, resourceType as any);\n\n    // Protection Against 'The List Problem' / Query Payload Exhaustion:\n    // If a badly designed ReBAC schema generates a monstrous combinatorial AST tree, \n    // it could exceed max SQL text limits resulting in DB crashes. Abort safely.\n    if (ast && ast.conditions.length > 100) {\n      throw new Error(`[Zanzo] Security Exception: The resulting AST exceeds the maximum safe limit of 100 conditional branches. Please optimize your schema or rely on pre-computed tuples to avoid database exhaustion.`);\n    }\n\n    if (!ast) {\n      // Access totally denied\n      return sql`1 = 0`; \n    }\n\n    const parseCondition = (cond: Condition): SQL<unknown> | undefined => {\n      \n      // In the Zanzibar Pattern, ALL conditions (direct or nested) ultimately result\n      // in looking up pre-computed or dynamically queried tuples.\n      // E.g for a direct target: SELECT 1 FROM tuples WHERE object = TYPE:ID AND relation = X AND subject = TARGET\n      \n      const objectString = sql`${resourceType} || '${sql.raw(ENTITY_REF_SEPARATOR)}' || ${resourceIdColumn}`;\n\n      // In Zanzibar, nested conditions (e.g. org.admin) are evaluated using the \"Tuple Expansion\" pattern.\n      // This means the user has asynchronously written materialized tuples into the database.\n      // Therefore, both direct and nested queries are resolved identically via O(1) EXISTS lookups.\n      if (cond.type === 'nested' && shouldWarn) {\n        console.warn(`[Zanzo] Nested permission path detected: '${[cond.relation, ...cond.nextRelationPath].join(RELATION_PATH_SEPARATOR)}'. The SQL adapter resolves this via pre-materialized tuples. Ensure you used expandTuples() when writing this relationship to the database. See: https://zanzo.dev/docs/tuple-expansion`);\n      }\n\n      const relationString = cond.type === 'nested' \n        ? [cond.relation, ...cond.nextRelationPath].join(RELATION_PATH_SEPARATOR) \n        : cond.relation;\n\n      return sql`EXISTS (\n        SELECT 1 FROM ${tupleTable} \n        WHERE ${tupleTable.object} = ${objectString} \n          AND ${tupleTable.relation} = ${relationString} \n          AND ${tupleTable.subject} = ${cond.targetSubject}\n      )`;\n    };\n\n    const parsedConditions = ast.conditions\n      .map(parseCondition)\n      .filter((c): c is SQL<unknown> => c !== undefined);\n\n    if (parsedConditions.length === 0) {\n       return sql`1 = 0`;\n    }\n\n    if (ast.operator === 'AND') {\n      return and(...parsedConditions) as SQL<unknown>;\n    }\n\n    return or(...parsedConditions) as SQL<unknown>;\n  };\n}\n"],"mappings":";AAAA,SAAS,IAAI,KAAU,WAAsB;AAE7C,SAAS,sBAAsB,+BAA+B;AA+BvD,SAAS,mBACd,QACA,YACA,SACA;AAEA,QAAM,QAAQ,OAAO,YAAY,eAAe,QAAQ,KAAK,aAAa;AAC1E,QAAM,aAAa,SAAS,0BAA0B;AAUtD,SAAO,SAAS,gBAId,OACA,QACA,cACA,kBACc;AAGd,UAAM,MAAM,OAAO,mBAAmB,OAAO,QAAe,YAAmB;AAK/E,QAAI,OAAO,IAAI,WAAW,SAAS,KAAK;AACtC,YAAM,IAAI,MAAM,oMAAoM;AAAA,IACtN;AAEA,QAAI,CAAC,KAAK;AAER,aAAO;AAAA,IACT;AAEA,UAAM,iBAAiB,CAAC,SAA8C;AAMpE,YAAM,eAAe,MAAM,YAAY,QAAQ,IAAI,IAAI,oBAAoB,CAAC,QAAQ,gBAAgB;AAKpG,UAAI,KAAK,SAAS,YAAY,YAAY;AACxC,gBAAQ,KAAK,6CAA6C,CAAC,KAAK,UAAU,GAAG,KAAK,gBAAgB,EAAE,KAAK,uBAAuB,CAAC,0LAA0L;AAAA,MAC7T;AAEA,YAAM,iBAAiB,KAAK,SAAS,WACjC,CAAC,KAAK,UAAU,GAAG,KAAK,gBAAgB,EAAE,KAAK,uBAAuB,IACtE,KAAK;AAET,aAAO;AAAA,wBACW,UAAU;AAAA,gBAClB,WAAW,MAAM,MAAM,YAAY;AAAA,gBACnC,WAAW,QAAQ,MAAM,cAAc;AAAA,gBACvC,WAAW,OAAO,MAAM,KAAK,aAAa;AAAA;AAAA,IAEtD;AAEA,UAAM,mBAAmB,IAAI,WAC1B,IAAI,cAAc,EAClB,OAAO,CAAC,MAAyB,MAAM,MAAS;AAEnD,QAAI,iBAAiB,WAAW,GAAG;AAChC,aAAO;AAAA,IACV;AAEA,QAAI,IAAI,aAAa,OAAO;AAC1B,aAAO,IAAI,GAAG,gBAAgB;AAAA,IAChC;AAEA,WAAO,GAAG,GAAG,gBAAgB;AAAA,EAC/B;AACF;","names":[]}

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@zanzojs/drizzle",
+  "version": "0.1.0-beta.0",
+  "description": "Drizzle ORM adapter for Zanzo ReBAC. Zero-config Zanzibar Tuple Pattern with parameterized SQL.",
+  "keywords": [
+    "@zanzojs/core",
+    "drizzle",
+    "drizzle-orm",
+    "rebac",
+    "authorization",
+    "zanzibar"
+  ],
+  "homepage": "https://github.com/GonzaloJeria/zanzo",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/GonzaloJeria/zanzo.git",
+    "directory": "packages/drizzle"
+  },
+  "license": "MIT",
+  "author": "Gonzalo Jeria",
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "publishConfig": {
+    "access": "public"
+  },
+  "peerDependencies": {
+    "@zanzojs/core": "^0.1.0-beta.0",
+    "drizzle-orm": ">=0.29.0"
+  },
+  "devDependencies": {
+    "drizzle-orm": "^0.30.0",
+    "typescript": "^5.7.2",
+    "tsup": "latest",
+    "vitest": "latest",
+    "@zanzojs/core": "0.1.0-beta.0"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "test:types": "vitest run --typecheck"
+  }
+}