@typed-policy/drizzle 0.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 Togle Labs <m.ihsan.vp@gmail.com>
+
+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.d.ts

@@ -0,0 +1,44 @@
+import { Expr, EvalContext } from '@typed-policy/core';
+import { AnyColumn, SQL } from 'drizzle-orm';
+
+/** Policy action type - matches the type in policy.ts */
+type PolicyAction<T, A> = Expr<T, A> | boolean | ((ctx: EvalContext<A>) => boolean | Expr<T, A>);
+type TableMapping<T> = {
+    [K in keyof T]: {
+        [P in keyof T[K]]: AnyColumn;
+    };
+};
+type CompileOptions<T, A> = {
+    actor: A;
+    tables: TableMapping<T>;
+};
+/**
+ * Compile a policy action to Drizzle SQL
+ *
+ * The key insight: since functions are pure, we execute them during compilation
+ * with the provided actor context. This gives us the resulting expression,
+ * which we then compile to SQL.
+ *
+ * @example
+ * ```typescript
+ * const listCondition = compile(postPolicy.actions.list, {
+ *   actor,
+ *   tables: {
+ *     post: {
+ *       id: posts.id,
+ *       ownerId: posts.ownerId,
+ *       published: posts.published
+ *     }
+ *   }
+ * });
+ * ```
+ */
+declare function compile<T, A>(action: PolicyAction<T, A>, options: CompileOptions<T, A>): SQL;
+
+type PathMapping<T> = {
+    [K in keyof T]?: AnyColumn;
+};
+declare function createMapping<T>(mappings: PathMapping<T>): PathMapping<T>;
+declare function validateMapping<T>(path: string, mapping: PathMapping<T>): boolean;
+
+export { type CompileOptions, type PathMapping, type TableMapping, compile, createMapping, validateMapping };

package/dist/index.js

@@ -0,0 +1,128 @@
+// src/compile.ts
+import { and as drizzleAnd, eq as drizzleEq, or as drizzleOr, sql } from "drizzle-orm";
+function getColumnFromPath(path, tables) {
+  const parts = path.split(".");
+  const tableKey = parts[0];
+  const columnKey = parts[1];
+  const table = tables[tableKey];
+  if (!table) {
+    throw new Error(
+      `Cannot compile path "${path}" to SQL: "${String(tableKey)}" is not a subject table. Only subject paths (mapped in tables) are allowed in SQL compilation. Available subject tables: ${Object.keys(tables).join(", ")}`
+    );
+  }
+  const column = table[columnKey];
+  if (!column) {
+    throw new Error(
+      `Cannot compile path "${path}" to SQL: "${String(columnKey)}" is not a valid column on table "${String(tableKey)}". Available columns: ${Object.keys(table).join(", ")}`
+    );
+  }
+  return column;
+}
+function isActorPath(path, tables) {
+  const parts = path.split(".");
+  const tableKey = parts[0];
+  return !(tableKey in tables);
+}
+function getActorValueFromPath(path, actor) {
+  const parts = path.split(".");
+  let current = actor;
+  for (let i = 0; i < parts.length; i++) {
+    if (current === null || current === void 0) {
+      return void 0;
+    }
+    current = current[parts[i]];
+  }
+  return current;
+}
+function resolveRightValue(right, tables, actor) {
+  if (typeof right === "string" && right.includes(".")) {
+    if (isActorPath(right, tables)) {
+      const value = getActorValueFromPath(right, actor);
+      if (value === void 0) {
+        throw new Error(
+          `Actor value not found for path: ${right}. Ensure the path exists in the actor object provided to compile().`
+        );
+      }
+      return value;
+    }
+    throw new Error(
+      `Cannot use subject path "${right}" on the right side of eq(). SQL compilation only supports subject paths on the left side (for column references) and actor paths on the right side (for parameterized values).`
+    );
+  }
+  return right;
+}
+function compile(action, options) {
+  const { actor, tables } = options;
+  if (typeof action === "boolean") {
+    return action ? sql`1 = 1` : sql`1 = 0`;
+  }
+  if (typeof action === "function") {
+    const result = action({
+      actor
+    });
+    if (typeof result === "boolean") {
+      return result ? sql`1 = 1` : sql`1 = 0`;
+    }
+    return compileExpr(result, tables, actor);
+  }
+  return compileExpr(action, tables, actor);
+}
+function compileExpr(expr, tables, actor) {
+  switch (expr.kind) {
+    case "literal": {
+      return expr.value ? sql`1 = 1` : sql`1 = 0`;
+    }
+    case "eq": {
+      const column = getColumnFromPath(expr.left, tables);
+      const value = resolveRightValue(
+        expr.right,
+        tables,
+        actor
+      );
+      return drizzleEq(column, value);
+    }
+    case "and": {
+      if (expr.rules.length === 0) {
+        return sql`1 = 1`;
+      }
+      const conditions = expr.rules.map((rule) => compileExpr(rule, tables, actor));
+      const result = drizzleAnd(...conditions);
+      return result || sql`1 = 1`;
+    }
+    case "or": {
+      if (expr.rules.length === 0) {
+        return sql`1 = 0`;
+      }
+      const conditions = expr.rules.map((rule) => compileExpr(rule, tables, actor));
+      const result = drizzleOr(...conditions);
+      return result || sql`1 = 0`;
+    }
+    case "function": {
+      const result = expr.fn({
+        actor
+      });
+      if (typeof result === "boolean") {
+        return result ? sql`1 = 1` : sql`1 = 0`;
+      }
+      return compileExpr(result, tables, actor);
+    }
+    default: {
+      throw new Error(`Unknown expression kind: ${JSON.stringify(expr)}`);
+    }
+  }
+}
+
+// src/mapping.ts
+function createMapping(mappings) {
+  return mappings;
+}
+function validateMapping(path, mapping) {
+  const parts = path.split(".");
+  const root = parts[0];
+  return root in mapping;
+}
+export {
+  compile,
+  createMapping,
+  validateMapping
+};

package/package.json

@@ -0,0 +1,57 @@
+{
+  "name": "@typed-policy/drizzle",
+  "version": "0.2.0",
+  "description": "Drizzle ORM SQL compiler for typed policies",
+  "author": "Ihsan VP <m.ihsan.vp@gmail.com>",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/toglelabs/typed-policy.git",
+    "directory": "packages/drizzle"
+  },
+  "homepage": "https://github.com/toglelabs/typed-policy/tree/main/packages/drizzle#readme",
+  "bugs": {
+    "url": "https://github.com/toglelabs/typed-policy/issues"
+  },
+  "keywords": [
+    "typescript",
+    "policy",
+    "authorization",
+    "drizzle",
+    "orm",
+    "sql",
+    "database"
+  ],
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "dependencies": {
+    "@typed-policy/core": "0.2.0"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.29.0"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "tsup": "^8.3.0",
+    "vitest": "^2.0.0",
+    "drizzle-orm": "^0.38.0"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts",
+    "typecheck": "tsc --noEmit",
+    "test": "vitest",
+    "clean": "rm -rf dist",
+    "lint": "biome check src",
+    "format": "biome format --write src"
+  }
+}