prisma-prefixed-ids 1.6.1 → 2.0.0

package/README.md

@@ -14,6 +14,8 @@ npm install prisma-prefixed-ids
 
 ## Usage
 
+### Object-Based Prefixes (Simple Configuration)
+
 ```typescript
 import { type Prisma, PrismaClient } from "@prisma/client";
 import { extendPrismaClient } from 'prisma-prefixed-ids';
@@ -26,7 +28,7 @@ type ModelName = Prisma.ModelName;
 // Create your Prisma client
 const prisma = new PrismaClient();
 
-// Define your model prefixes
+// Define your model prefixes as an object
 const prefixes: Partial<Record<ModelName, string>> = {
   Organization: 'org',
   User: 'usr',
@@ -54,6 +56,63 @@ const organization = await extendedPrisma.organization.create({
 console.log(organization.id); // e.g., 'org_abc123...'
 ```
 
+### Function-Based Prefixes (Dynamic Configuration)
+
+You can also use a function to determine prefixes dynamically. This is useful when you need conditional logic or want to compute prefixes based on the model name:
+
+```typescript
+import { type Prisma, PrismaClient } from "@prisma/client";
+import { extendPrismaClient } from 'prisma-prefixed-ids';
+
+type ModelName = Prisma.ModelName;
+
+const prisma = new PrismaClient();
+
+// Define prefixes using a function
+const extendedPrisma = extendPrismaClient(prisma, {
+  prefixes: (modelName: ModelName): string | null => {
+    // Return prefix for known models, null for unknown models
+    switch (modelName) {
+      case 'Organization':
+        return 'org';
+      case 'User':
+        return 'usr';
+      case 'Post':
+        return 'pst';
+      case 'Comment':
+        return 'cmt';
+      default:
+        return null; // No prefix for unknown models
+    }
+  },
+});
+
+// Or use a more dynamic approach
+const extendedPrismaDynamic = extendPrismaClient(prisma, {
+  prefixes: (modelName: ModelName): string | null => {
+    // Convert model name to lowercase prefix
+    const prefix = modelName.toLowerCase().slice(0, 3);
+    // Only apply to certain models
+    const allowedModels = ['User', 'Post', 'Comment'];
+    return allowedModels.includes(modelName) ? prefix : null;
+  },
+});
+
+// Use the extended client
+const user = await extendedPrisma.user.create({
+  data: {
+    name: 'John Doe',
+    // id will be automatically generated with prefix 'usr_'
+  },
+});
+
+console.log(user.id); // e.g., 'usr_abc123...'
+```
+
+**Note:** When using function-based prefixes, return `null` for models that should not have prefixed IDs. The extension will skip ID generation for those models.
+
+**Backward Compatibility:** The function-based prefix feature is fully backward compatible. Existing code using object-based prefixes will continue to work without any changes.
+
 ## Nested Writes Support (v1.5.0+)
 
 Since version 1.5.0, this package fully supports **nested writes** with automatic ID generation for all related records. This includes complex relationship operations like:
@@ -241,6 +300,7 @@ const customIdGenerator = (prefix: string) => {
   return `${prefix}_${nanoid()}`;
 };
 
+// With object-based prefixes
 const extendedPrisma = extendPrismaClient(prisma, {
   prefixes: {
     Organization: 'org',
@@ -248,18 +308,32 @@ const extendedPrisma = extendPrismaClient(prisma, {
   },
   idGenerator: customIdGenerator,
 });
+
+// With function-based prefixes
+const extendedPrismaWithFunction = extendPrismaClient(prisma, {
+  prefixes: (modelName) => {
+    if (modelName === 'Organization') return 'org';
+    if (modelName === 'User') return 'usr';
+    return null;
+  },
+  idGenerator: customIdGenerator,
+});
 ```
 
 ## Configuration Options
 
 The extension accepts the following configuration:
 
-- `prefixes`: A record mapping model names to their prefixes (required)
+- `prefixes`: Either an object mapping model names to prefixes, or a function that returns a prefix for a given model name (required)
 - `idGenerator`: A function that generates IDs (optional, defaults to using nanoid)
 
 ### Prefixes Configuration
 
-The `prefixes` configuration is a simple object where:
+The `prefixes` configuration can be provided in two ways:
+
+#### Option 1: Object-Based (Simple)
+
+A simple object where:
 - Keys are your Prisma model names (case sensitive)
 - Values are the prefixes you want to use (without the underscore, which is added automatically)
 
@@ -273,6 +347,45 @@ const prefixes = {
 };
 ```
 
+#### Option 2: Function-Based (Dynamic)
+
+A function that takes a model name and returns a prefix string or `null`:
+- Accepts `modelName: ModelName` as parameter
+- Returns `string | null`:
+  - Returns a `string` prefix for models that should have prefixed IDs
+  - Returns `null` for models that should not have prefixed IDs
+
+Example:
+```typescript
+const prefixes = (modelName: ModelName): string | null => {
+  // Simple mapping
+  const prefixMap: Record<string, string> = {
+    Organization: 'org',
+    User: 'usr',
+    Post: 'pst',
+    Comment: 'cmt',
+  };
+  return prefixMap[modelName] ?? null;
+};
+
+// Or with conditional logic
+const prefixes = (modelName: ModelName): string | null => {
+  if (modelName.startsWith('System')) {
+    return 'sys'; // All system models get 'sys' prefix
+  }
+  if (modelName === 'User' || modelName === 'Organization') {
+    return modelName.toLowerCase().slice(0, 3);
+  }
+  return null; // Other models get no prefix
+};
+```
+
+**When to use function-based prefixes:**
+- You need conditional logic based on model names
+- You want to compute prefixes dynamically
+- You have a large number of models and want to avoid maintaining a large object
+- You need to apply prefixes based on naming patterns or conventions
+
 ### ID Generator Function
 
 The `idGenerator` function should:

package/dist/index.cjs

@@ -172,6 +172,15 @@ function createPrefixedIdsExtension(config, dmmf) {
     }
     const { prefixes, idGenerator = defaultIdGenerator } = config;
     const prefixedId = (modelName) => {
+        // Check if prefixes is a function
+        if (typeof prefixes === "function") {
+            const prefix = prefixes(modelName);
+            if (prefix === null) {
+                return null;
+            }
+            return idGenerator(prefix);
+        }
+        // Otherwise, treat it as an object/map
         if (modelName in prefixes) {
             return idGenerator(prefixes[modelName]);
         }

package/dist/index.d.ts

@@ -1,7 +1,15 @@
-import { type PrismaClient } from "@prisma/client";
 export type ModelName = string;
+/**
+ * Minimal interface representing a Prisma Client instance.
+ * This allows the library to work with any Prisma Client version (v6, v7+)
+ * without importing from @prisma/client directly.
+ */
+export interface PrismaClientLike {
+    $extends: (extension: any) => any;
+    [key: string]: any;
+}
 export type PrefixConfig<ModelName extends string> = {
-    prefixes: Partial<Record<ModelName, string>>;
+    prefixes: Partial<Record<ModelName, string>> | ((modelName: ModelName) => string | null);
     idGenerator?: (prefix: string) => string;
 };
 type QueryArgs = {
@@ -24,7 +32,7 @@ export declare function createPrefixedIdsExtension<ModelName extends string>(con
         };
     };
 };
-export declare function extendPrismaClient<ModelName extends string = string, Client extends PrismaClient = PrismaClient>(prisma: Client, config: PrefixConfig<ModelName>): Client;
-export declare function getDMMF(clientOrContext: PrismaClient | any): any;
-export declare function getModelNames(prismaClient: PrismaClient): string[];
+export declare function extendPrismaClient<ModelName extends string = string, Client extends PrismaClientLike = PrismaClientLike>(prisma: Client, config: PrefixConfig<ModelName>): Client;
+export declare function getDMMF(clientOrContext: PrismaClientLike | any): any;
+export declare function getModelNames(prismaClient: PrismaClientLike): string[];
 export {};

package/dist/index.js

@@ -163,6 +163,15 @@ export function createPrefixedIdsExtension(config, dmmf) {
     }
     const { prefixes, idGenerator = defaultIdGenerator } = config;
     const prefixedId = (modelName) => {
+        // Check if prefixes is a function
+        if (typeof prefixes === "function") {
+            const prefix = prefixes(modelName);
+            if (prefix === null) {
+                return null;
+            }
+            return idGenerator(prefix);
+        }
+        // Otherwise, treat it as an object/map
         if (modelName in prefixes) {
             return idGenerator(prefixes[modelName]);
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prisma-prefixed-ids",
-  "version": "1.6.1",
+  "version": "2.0.0",
   "description": "A Prisma extension that adds prefixed IDs to your models",
   "type": "module",
   "main": "./dist/index.js",
@@ -28,9 +28,17 @@
     "clean:test-artifacts": "rm -rf test-client prisma/test.db prisma/test.db-journal",
     "test": "npm run test:unit && npm run test:integration",
     "test:unit": "jest --testPathIgnorePatterns=integration",
-    "test:integration": "npm run db:setup && jest --testPathPattern=integration",
+    "test:integration": "npm run db:setup && jest --testPathPattern=integration --testPathIgnorePatterns='integration.mysql|integration.postgres'",
+    "test:mysql": "npm run db:setup:mysql && jest --testPathPattern=integration.mysql",
+    "test:postgres": "npm run db:setup:postgres && jest --testPathPattern=integration.postgres",
+    "db:setup:mysql": "npm run db:generate:mysql && npm run db:push:mysql",
+    "db:generate:mysql": "prisma generate --schema=tests/prisma/schema.mysql.prisma",
+    "db:push:mysql": "prisma db push --schema=tests/prisma/schema.mysql.prisma",
+    "db:setup:postgres": "npm run db:generate:postgres && npm run db:push:postgres",
+    "db:generate:postgres": "prisma generate --schema=tests/prisma/schema.postgres.prisma",
+    "db:push:postgres": "prisma db push --schema=tests/prisma/schema.postgres.prisma",
     "test:watch": "jest --watch",
-    "test:coverage": "jest --coverage --collectCoverageFrom='src/**/*.ts' --coveragePathIgnorePatterns='src/__tests__'",
+    "test:coverage": "jest --coverage --collectCoverageFrom='src/**/*.ts' --coveragePathIgnorePatterns='src/__tests__' --testPathIgnorePatterns='integration'",
     "db:setup": "npm run db:generate && npm run db:push",
     "db:generate": "prisma generate",
     "db:push": "prisma db push",
@@ -39,7 +47,8 @@
     "lint:fix": "eslint . --ext .ts --fix",
     "format": "prettier --write \"src/**/*.ts\"",
     "format:check": "prettier --check \"src/**/*.ts\"",
-    "git:push": "git push && git push --tags"
+    "git:push": "git push && git push --tags",
+    "trypublish": "npm publish --access public"
   },
   "keywords": [
     "prisma",
@@ -51,25 +60,30 @@
   "author": "Prageeth Silva <prageeth@codemode.com.au>",
   "license": "MIT",
   "dependencies": {
-    "@prisma/client": "^5.0.0 || ^6.0.0",
+    "@prisma/client": "^6.0.0 || ^7.0.0",
     "nanoid": "^5.0.0"
   },
   "devDependencies": {
+    "@libsql/client": "^0.17.0",
+    "@prisma/adapter-libsql": "^7.3.0",
+    "@prisma/adapter-mariadb": "^7.3.0",
+    "@prisma/adapter-pg": "^7.3.0",
     "@types/jest": "^29.0.0",
-    "@types/node": "^20.0.0",
     "@types/nanoid": "^2.0.0",
+    "@types/node": "^22.0.0",
     "@typescript-eslint/eslint-plugin": "^6.0.0",
     "@typescript-eslint/parser": "^6.0.0",
+    "dotenv": "^16.0.0",
     "eslint": "^8.56.0",
     "eslint-config-prettier": "^9.0.0",
     "jest": "^29.0.0",
     "prettier": "^3.0.0",
-    "prisma": "^5.0.0",
+    "prisma": "^7.0.0",
     "ts-jest": "^29.0.0",
     "typescript": "^5.0.0"
   },
   "peerDependencies": {
-    "@prisma/client": "^5.0.0 || ^6.0.0"
+    "@prisma/client": "^6.0.0 || ^7.0.0"
   },
   "prisma": {
     "schema": "tests/prisma/schema.prisma"