@toride/prisma 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+import { ConstraintAdapter, ResourceRef } from 'toride';
+
+declare const VERSION = "0.0.1";
+
+/** Prisma WHERE clause type (plain object). */
+type PrismaWhere = Record<string, unknown>;
+/** Options for createPrismaAdapter. */
+interface PrismaAdapterOptions {
+    /** Maps constraint relation fields to Prisma relation names. */
+    relationMapping?: Record<string, string>;
+    /** Prisma table name for role assignments. Default: "roleAssignments". */
+    roleAssignmentTable?: string;
+    /** Field names in the role assignment table. */
+    roleAssignmentFields?: {
+        userId?: string;
+        role?: string;
+    };
+}
+/**
+ * Create a Prisma constraint adapter that translates constraint AST
+ * nodes into Prisma WHERE clause objects.
+ *
+ * No Prisma dependency required - produces plain JS objects matching
+ * Prisma's WHERE clause structure.
+ */
+declare function createPrismaAdapter(options?: PrismaAdapterOptions): ConstraintAdapter<PrismaWhere>;
+/** Options for createPrismaResolver. */
+interface PrismaResolverOptions {
+    /** Fields to select. Defaults to all scalar fields. */
+    select?: Record<string, boolean>;
+}
+/**
+ * Creates a resolver function for a Prisma model.
+ * Wraps a Prisma findUnique query into the ResourceResolver signature.
+ *
+ * The client parameter is duck-typed — no direct @prisma/client dependency
+ * is required. The client must support `client[modelName].findUnique({ where: { id } })`.
+ *
+ * @param client - A Prisma client instance (duck-typed).
+ * @param modelName - The Prisma model name (lowercase, e.g. "document").
+ * @param options - Optional configuration.
+ * @returns A ResourceResolver function.
+ */
+declare function createPrismaResolver(client: any, modelName: string, options?: PrismaResolverOptions): (ref: ResourceRef) => Promise<Record<string, unknown>>;
+
+export { type PrismaAdapterOptions, type PrismaResolverOptions, type PrismaWhere, VERSION, createPrismaAdapter, createPrismaResolver };

package/dist/index.js

@@ -0,0 +1,82 @@
+// src/index.ts
+var VERSION = "0.0.1";
+function createPrismaAdapter(options) {
+  const relationMapping = options?.relationMapping ?? {};
+  const roleTable = options?.roleAssignmentTable ?? "roleAssignments";
+  const userIdField = options?.roleAssignmentFields?.userId ?? "userId";
+  const roleField = options?.roleAssignmentFields?.role ?? "role";
+  return {
+    translate(constraint) {
+      switch (constraint.type) {
+        case "field_eq":
+          return { [constraint.field]: constraint.value };
+        case "field_neq":
+          return { [constraint.field]: { not: constraint.value } };
+        case "field_gt":
+          return { [constraint.field]: { gt: constraint.value } };
+        case "field_gte":
+          return { [constraint.field]: { gte: constraint.value } };
+        case "field_lt":
+          return { [constraint.field]: { lt: constraint.value } };
+        case "field_lte":
+          return { [constraint.field]: { lte: constraint.value } };
+        case "field_in":
+          return { [constraint.field]: { in: constraint.values } };
+        case "field_nin":
+          return { [constraint.field]: { notIn: constraint.values } };
+        case "field_exists":
+          return constraint.exists ? { [constraint.field]: { not: null } } : { [constraint.field]: null };
+        case "field_includes":
+          return { [constraint.field]: { has: constraint.value } };
+        case "field_contains":
+          return { [constraint.field]: { contains: constraint.value } };
+        default: {
+          const _exhaustive = constraint;
+          throw new Error(`Unknown constraint type: ${constraint.type}`);
+        }
+      }
+    },
+    relation(field, _resourceType, childQuery) {
+      const prismaRelation = relationMapping[field] ?? field;
+      return { [prismaRelation]: childQuery };
+    },
+    hasRole(actorId, _actorType, role) {
+      return {
+        [roleTable]: {
+          some: {
+            [userIdField]: actorId,
+            [roleField]: role
+          }
+        }
+      };
+    },
+    unknown(_name) {
+      return {};
+    },
+    and(queries) {
+      return { AND: queries };
+    },
+    or(queries) {
+      return { OR: queries };
+    },
+    not(query) {
+      return { NOT: query };
+    }
+  };
+}
+function createPrismaResolver(client, modelName, options) {
+  return async (ref) => {
+    const model = client[modelName];
+    const query = { where: { id: ref.id } };
+    if (options?.select) {
+      query.select = options.select;
+    }
+    const result = await model.findUnique(query);
+    return result ?? {};
+  };
+}
+export {
+  VERSION,
+  createPrismaAdapter,
+  createPrismaResolver
+};

package/package.json

@@ -0,0 +1,43 @@
+{
+  "name": "@toride/prisma",
+  "version": "0.1.0",
+  "description": "Prisma 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"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "authorization",
+    "prisma",
+    "toride"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/toride-auth/toride"
+  },
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "tsc --noEmit"
+  }
+}