@toride/drizzle 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,59 @@
+import { ConstraintAdapter, ResourceRef } from 'toride';
+
+declare const VERSION = "0.0.1";
+
+/**
+ * Drizzle query representation.
+ * Produces intermediate objects that describe the query operation.
+ * Users can pass these to their own Drizzle query builder or use
+ * the provided `toDrizzle()` helper when drizzle-orm is available.
+ */
+type DrizzleQuery = Record<string, unknown>;
+/** Table reference type (generic for any Drizzle table). */
+type AnyTable = Record<string, any>;
+/** Relation configuration for the adapter. */
+interface RelationConfig {
+    table: AnyTable;
+    foreignKey: string;
+}
+/** Role assignment configuration. */
+interface RoleAssignmentConfig {
+    table: AnyTable;
+    userIdColumn: string;
+    roleColumn: string;
+}
+/** Options for createDrizzleAdapter. */
+interface DrizzleAdapterOptions {
+    /** Maps relation fields to Drizzle table references and foreign keys. */
+    relations?: Record<string, RelationConfig>;
+    /** Role assignment table configuration. */
+    roleAssignments?: RoleAssignmentConfig;
+}
+/**
+ * Create a Drizzle constraint adapter for a specific table.
+ *
+ * Produces intermediate query description objects that capture the
+ * operation type, field, and value. These can be used with drizzle-orm
+ * operators or processed by custom query builders.
+ */
+declare function createDrizzleAdapter(table: AnyTable, options?: DrizzleAdapterOptions): ConstraintAdapter<DrizzleQuery>;
+/** Options for createDrizzleResolver. */
+interface DrizzleResolverOptions {
+    /** Column used as the resource ID. Defaults to "id". */
+    idColumn?: string;
+}
+/**
+ * Creates a resolver function for a Drizzle table.
+ * Wraps a Drizzle select query into the ResourceResolver signature.
+ *
+ * The db and table parameters are duck-typed — no direct drizzle-orm
+ * dependency is required. The db object must support `db.select().from(table).where(condition)`.
+ *
+ * @param db - A Drizzle database instance (duck-typed).
+ * @param table - A Drizzle table reference (duck-typed).
+ * @param options - Optional configuration.
+ * @returns A ResourceResolver function.
+ */
+declare function createDrizzleResolver(db: any, table: any, options?: DrizzleResolverOptions): (ref: ResourceRef) => Promise<Record<string, unknown>>;
+
+export { type AnyTable, type DrizzleAdapterOptions, type DrizzleQuery, type DrizzleResolverOptions, type RelationConfig, type RoleAssignmentConfig, VERSION, createDrizzleAdapter, createDrizzleResolver };

package/dist/index.js

@@ -0,0 +1,95 @@
+// src/index.ts
+var VERSION = "0.0.1";
+function createDrizzleAdapter(table, options) {
+  const relations = options?.relations ?? {};
+  const roleAssignments = options?.roleAssignments;
+  return {
+    translate(constraint) {
+      switch (constraint.type) {
+        case "field_eq":
+          return { _op: "eq", field: constraint.field, value: constraint.value, table };
+        case "field_neq":
+          return { _op: "ne", field: constraint.field, value: constraint.value, table };
+        case "field_gt":
+          return { _op: "gt", field: constraint.field, value: constraint.value, table };
+        case "field_gte":
+          return { _op: "gte", field: constraint.field, value: constraint.value, table };
+        case "field_lt":
+          return { _op: "lt", field: constraint.field, value: constraint.value, table };
+        case "field_lte":
+          return { _op: "lte", field: constraint.field, value: constraint.value, table };
+        case "field_in":
+          return { _op: "inArray", field: constraint.field, values: constraint.values, table };
+        case "field_nin":
+          return { _op: "notInArray", field: constraint.field, values: constraint.values, table };
+        case "field_exists":
+          return constraint.exists ? { _op: "isNotNull", field: constraint.field, table } : { _op: "isNull", field: constraint.field, table };
+        case "field_includes":
+          return { _op: "arrayContains", field: constraint.field, value: constraint.value, table };
+        case "field_contains": {
+          const escaped = String(constraint.value).replace(/[%_\\]/g, "\\$&");
+          return { _op: "like", field: constraint.field, pattern: `%${escaped}%`, table };
+        }
+        default: {
+          const _exhaustive = constraint;
+          throw new Error(`Unknown constraint type: ${constraint.type}`);
+        }
+      }
+    },
+    relation(field, resourceType, childQuery) {
+      const relationConfig = relations[field];
+      if (relationConfig) {
+        return {
+          _op: "relation",
+          field,
+          resourceType,
+          child: childQuery,
+          relatedTable: relationConfig.table,
+          foreignKey: relationConfig.foreignKey
+        };
+      }
+      return { _op: "relation", field, resourceType, child: childQuery };
+    },
+    hasRole(actorId, actorType, role) {
+      if (roleAssignments) {
+        return {
+          _op: "hasRole",
+          actorId,
+          actorType,
+          role,
+          roleTable: roleAssignments.table,
+          userIdColumn: roleAssignments.userIdColumn,
+          roleColumn: roleAssignments.roleColumn
+        };
+      }
+      return { _op: "hasRole", actorId, actorType, role };
+    },
+    unknown(_name) {
+      return { _op: "literal", value: true };
+    },
+    and(queries) {
+      return { _op: "and", children: queries };
+    },
+    or(queries) {
+      return { _op: "or", children: queries };
+    },
+    not(query) {
+      return { _op: "not", child: query };
+    }
+  };
+}
+function createDrizzleResolver(db, table, options) {
+  const idColumn = options?.idColumn ?? "id";
+  return async (ref) => {
+    const rows = await db.select().from(table).where({ [idColumn]: ref.id });
+    if (!rows || rows.length === 0) {
+      return {};
+    }
+    return rows[0];
+  };
+}
+export {
+  VERSION,
+  createDrizzleAdapter,
+  createDrizzleResolver
+};

package/package.json

@@ -0,0 +1,51 @@
+{
+  "name": "@toride/drizzle",
+  "version": "0.1.0",
+  "description": "Drizzle ORM integration for Toride authorization engine",
+  "type": "module",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "nx": {
+    "tags": [
+      "type:integration"
+    ]
+  },
+  "dependencies": {
+    "toride": "0.1.0"
+  },
+  "peerDependencies": {
+    "drizzle-orm": ">=0.29.0"
+  },
+  "peerDependenciesMeta": {
+    "drizzle-orm": {
+      "optional": true
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "authorization",
+    "drizzle",
+    "toride"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/toride-auth/toride"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  }
+}