prisma-prefixed-ids 1.6.0 → 1.7.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,7 @@
 import { type PrismaClient } from "@prisma/client";
 export type ModelName = string;
 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 = {

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.0",
+  "version": "1.7.0",
   "description": "A Prisma extension that adds prefixed IDs to your models",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,7 +39,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",
@@ -74,4 +75,4 @@
   "prisma": {
     "schema": "tests/prisma/schema.prisma"
   }
-}
+}