prisma-prefixed-ids 1.2.0 → 1.3.1

package/dist/index.cjs

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPrefixedIdsExtension = createPrefixedIdsExtension;
+exports.extendPrismaClient = extendPrismaClient;
+const nanoid_1 = require("nanoid");
+const defaultIdGenerator = (prefix) => {
+    const nanoid = (0, nanoid_1.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 24);
+    return `${prefix}_${nanoid()}`;
+};
+function createPrefixedIdsExtension(config) {
+    const { prefixes, idGenerator = defaultIdGenerator } = config;
+    const prefixedId = (modelName) => {
+        if (modelName in prefixes) {
+            return idGenerator(prefixes[modelName]);
+        }
+        return null;
+    };
+    return {
+        name: "prefixedIds",
+        query: {
+            $allModels: {
+                create: ({ args, query, model }) => {
+                    if (args.data && !args.data.id) {
+                        const id = prefixedId(model);
+                        if (id) {
+                            args.data.id = id;
+                        }
+                    }
+                    return query(args);
+                },
+                createMany: ({ args, query, model }) => {
+                    if (model in prefixes && args.data && Array.isArray(args.data)) {
+                        args.data = args.data.map((item) => {
+                            if (!item.id) {
+                                const id = prefixedId(model);
+                                if (id) {
+                                    return {
+                                        ...item,
+                                        id,
+                                    };
+                                }
+                            }
+                            return item;
+                        });
+                    }
+                    return query(args);
+                },
+            },
+        },
+    };
+}
+function extendPrismaClient(prisma, config) {
+    return prisma.$extends(createPrefixedIdsExtension(config));
+}

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { PrismaClient } from "@prisma/client";
+import type { PrismaClient } from "@prisma/client";
 type ModelName = string;
 export type PrefixConfig<ModelName extends string> = {
     prefixes: Partial<Record<ModelName, string>>;
@@ -18,5 +18,9 @@ export declare function createPrefixedIdsExtension<ModelName extends string>(con
         };
     };
 };
-export declare function extendPrismaClient<ModelName extends string = string>(prisma: PrismaClient, config: PrefixConfig<ModelName>): PrismaClient;
+export declare function extendPrismaClient<ModelName extends string = string, Client extends {
+    $extends: (extension: any) => Client;
+} = PrismaClient & {
+    $extends: (extension: any) => any;
+}>(prisma: Client, config: PrefixConfig<ModelName>): Client;
 export {};

package/dist/index.js

@@ -1,13 +1,9 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.createPrefixedIdsExtension = createPrefixedIdsExtension;
-exports.extendPrismaClient = extendPrismaClient;
-const nanoid_1 = require("nanoid");
+import { customAlphabet } from "nanoid";
 const defaultIdGenerator = (prefix) => {
-    const nanoid = (0, nanoid_1.customAlphabet)("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 24);
+    const nanoid = customAlphabet("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ", 24);
     return `${prefix}_${nanoid()}`;
 };
-function createPrefixedIdsExtension(config) {
+export function createPrefixedIdsExtension(config) {
     const { prefixes, idGenerator = defaultIdGenerator } = config;
     const prefixedId = (modelName) => {
         if (modelName in prefixes) {
@@ -49,6 +45,6 @@ function createPrefixedIdsExtension(config) {
         },
     };
 }
-function extendPrismaClient(prisma, config) {
+export function extendPrismaClient(prisma, config) {
     return prisma.$extends(createPrefixedIdsExtension(config));
 }

package/package.json

@@ -1,16 +1,29 @@
 {
   "name": "prisma-prefixed-ids",
-  "version": "1.2.0",
+  "version": "1.3.1",
   "description": "A Prisma extension that adds prefixed IDs to your models",
-  "main": "dist/index.js",
-  "types": "dist/index.d.ts",
   "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
   "repository": {
     "type": "git",
     "url": "https://github.com/pureartisan/prisma-prefixed-ids"
   },
   "scripts": {
-    "build": "tsc",
+    "clean": "rm -rf dist",
+    "build": "npm run clean && npm run build:esm && npm run build:cjs",
+    "build:esm": "tsc -p tsconfig.json",
+    "build:cjs": "tsc -p tsconfig.cjs.json && mv dist/cjs/index.js dist/index.cjs && rm -rf dist/cjs",
     "prepare": "npm run build",
     "test": "jest",
     "test:watch": "jest --watch",
@@ -28,7 +41,7 @@
     "prefixed",
     "nanoid"
   ],
-  "author": "Prageeth Silva <prageethsilva@gmail.com>",
+  "author": "Prageeth Silva <prageeth@codemode.com.au>",
   "license": "MIT",
   "dependencies": {
     "@prisma/client": "^5.0.0 || ^6.0.0",

package/.eslintrc.json

@@ -1,32 +0,0 @@
-{
-  "env": {
-    "node": true,
-    "es2021": true,
-    "jest": true
-  },
-  "extends": [
-    "eslint:recommended",
-    "plugin:@typescript-eslint/recommended",
-    "prettier"
-  ],
-  "parser": "@typescript-eslint/parser",
-  "parserOptions": {
-    "ecmaVersion": "latest",
-    "sourceType": "module"
-  },
-  "plugins": ["@typescript-eslint"],
-  "rules": {
-    "@typescript-eslint/explicit-function-return-type": "error",
-    "@typescript-eslint/no-explicit-any": "off",
-    "@typescript-eslint/no-unused-vars": [
-      "error",
-      { "argsIgnorePattern": "^_" }
-    ]
-  },
-  "ignorePatterns": [
-    "**/*.test.ts",
-    "**/*.spec.ts",
-    "dist/**/*",
-    "node_modules/**/*"
-  ]
-}

package/.github/workflows/ci.yml

@@ -1,39 +0,0 @@
-name: CI
-
-on:
-  push:
-    branches: [ main ]
-  pull_request:
-    branches: [ main ]
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    strategy:
-      matrix:
-        node-version: [18.x, 20.x]
-
-    steps:
-    - uses: actions/checkout@v4
-
-    - name: Use Node.js ${{ matrix.node-version }}
-      uses: actions/setup-node@v4
-      with:
-        node-version: ${{ matrix.node-version }}
-        cache: 'npm'
-
-    - name: Install dependencies
-      run: npm ci
-
-    - name: Check formatting
-      run: npm run format:check
-
-    - name: Run linter
-      run: npm run lint
-
-    - name: Build
-      run: npm run build
-
-    - name: Run tests with coverage
-      run: npm run test:coverage 

package/.prettierrc

@@ -1 +0,0 @@
- 

package/jest.config.cjs

@@ -1,16 +0,0 @@
-module.exports = {
-  preset: "ts-jest",
-  testEnvironment: "node",
-  testMatch: ["**/__tests__/**/*.ts", "**/?(*.)+(spec|test).ts"],
-  transform: {
-    "^.+\\.ts$": [
-      "ts-jest",
-      {
-        tsconfig: "tsconfig.test.json",
-      },
-    ],
-  },
-  moduleNameMapper: {
-    "^(\\.{1,2}/.*)\\.js$": "$1",
-  },
-};

package/src/__tests__/index.test.ts

@@ -1,184 +0,0 @@
-import { jest } from "@jest/globals";
-
-import { PrismaClient } from "@prisma/client";
-import {
-  createPrefixedIdsExtension,
-  extendPrismaClient,
-  PrefixConfig,
-} from "../index";
-
-type MockUser = {
-  id: string;
-  name: string;
-};
-
-type CreateArgs = {
-  data: Record<string, unknown>;
-};
-
-// Mock PrismaClient
-jest.mock("@prisma/client", () => {
-  return {
-    PrismaClient: jest.fn().mockImplementation(() => ({
-      $extends: jest.fn(),
-      user: {
-        create: jest.fn(),
-        findUnique: jest.fn(),
-      },
-    })),
-  };
-});
-
-// Mock nanoid
-jest.mock("nanoid", () => ({
-  customAlphabet: jest.fn().mockImplementation(() => () => "mock_nanoid_value"),
-}));
-
-describe("PrefixedIdsExtension", () => {
-  let prisma: jest.Mocked<PrismaClient>;
-  const mockQuery = jest.fn((args: any) => Promise.resolve(args));
-
-  beforeEach(() => {
-    jest.clearAllMocks();
-    prisma = new PrismaClient() as jest.Mocked<PrismaClient>;
-  });
-
-  describe("createPrefixedIdsExtension", () => {
-    it("should create an extension with the correct name", () => {
-      const extension = createPrefixedIdsExtension({
-        prefixes: {
-          Test: "test",
-        },
-      });
-
-      expect(extension.name).toBe("prefixedIds");
-    });
-
-    it("should use default idGenerator if none provided", async () => {
-      const extension = createPrefixedIdsExtension({
-        prefixes: {
-          Test: "test",
-        },
-      });
-
-      const result = await extension.query.$allModels.create({
-        args: { data: {} },
-        query: mockQuery,
-        model: "Test",
-      });
-
-      expect(result).toBeDefined();
-      expect(mockQuery).toHaveBeenCalled();
-    });
-
-    it("should use custom idGenerator if provided", async () => {
-      const customIdGenerator = jest.fn(
-        (prefix: string) => `${prefix}_custom_id`,
-      );
-      const extension = createPrefixedIdsExtension({
-        prefixes: {
-          Test: "test",
-        },
-        idGenerator: customIdGenerator,
-      });
-
-      await extension.query.$allModels.create({
-        args: { data: {} },
-        query: mockQuery,
-        model: "Test",
-      });
-
-      expect(customIdGenerator).toHaveBeenCalledWith("test");
-      expect(mockQuery).toHaveBeenCalledWith({
-        data: { id: "test_custom_id" },
-      });
-    });
-
-    it("should not modify args if model has no prefix", async () => {
-      const extension = createPrefixedIdsExtension({
-        prefixes: {
-          Test: "test",
-        },
-      });
-
-      const originalArgs = { data: {} };
-      const result = await extension.query.$allModels.create({
-        args: originalArgs,
-        query: mockQuery,
-        model: "UnknownModel",
-      });
-
-      expect(result).toBeDefined();
-      expect(result.data).not.toHaveProperty("id");
-    });
-
-    it("should handle createMany operation", async () => {
-      const extension = createPrefixedIdsExtension({
-        prefixes: {
-          Test: "test",
-        },
-      });
-
-      const result = await extension.query.$allModels.createMany({
-        args: {
-          data: [{}, {}],
-        },
-        query: mockQuery,
-        model: "Test",
-      });
-
-      expect(result).toBeDefined();
-      expect(result.data).toHaveLength(2);
-      expect(result.data[0]).toHaveProperty("id");
-      expect(result.data[1]).toHaveProperty("id");
-    });
-
-    it("should generate IDs with uppercase letters", async (): Promise<void> => {
-      const prefixConfig: PrefixConfig<"User"> = {
-        prefixes: {
-          User: "usr",
-        },
-        // Force an ID with uppercase for testing
-        idGenerator: (prefix: string): string => {
-          return `${prefix}_ABC123DEF`;
-        },
-      };
-
-      const extension = createPrefixedIdsExtension(prefixConfig);
-      prisma.$extends(extension);
-
-      // Mock the create operation
-      prisma.user.create.mockResolvedValueOnce({
-        id: "usr_ABC123DEF",
-        name: "Test User",
-      });
-
-      const user = await prisma.user.create({
-        data: {
-          name: "Test User",
-        },
-      });
-
-      // Test that the ID matches our pattern including uppercase
-      expect(user.id).toMatch(/^usr_[A-Z0-9]+$/);
-    });
-  });
-
-  describe("extendPrismaClient", () => {
-    it("should extend the Prisma client with the extension", () => {
-      const extendedPrisma = extendPrismaClient(prisma, {
-        prefixes: {
-          Test: "test",
-        },
-      });
-
-      expect(prisma.$extends).toHaveBeenCalled();
-    });
-
-    it("should not throw error if prefixes are not provided", () => {
-      expect(() => {
-        extendPrismaClient(prisma, {} as any);
-      }).not.toThrow();
-    });
-  });
-});

package/src/index.ts

@@ -1,87 +0,0 @@
-import { PrismaClient } from "@prisma/client";
-import { customAlphabet } from "nanoid";
-
-// Define ModelName type based on Prisma's model names
-type ModelName = string;
-
-export type PrefixConfig<ModelName extends string> = {
-  prefixes: Partial<Record<ModelName, string>>;
-  idGenerator?: (prefix: string) => string;
-};
-
-const defaultIdGenerator = (prefix: string): string => {
-  const nanoid = customAlphabet(
-    "0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ",
-    24,
-  );
-  return `${prefix}_${nanoid()}`;
-};
-
-type QueryArgs = {
-  args: any;
-  query: (args: any) => Promise<any>;
-  model: ModelName;
-};
-
-export function createPrefixedIdsExtension<ModelName extends string>(
-  config: PrefixConfig<ModelName>,
-): {
-  name: string;
-  query: {
-    $allModels: {
-      create: (args: QueryArgs) => Promise<any>;
-      createMany: (args: QueryArgs) => Promise<any>;
-    };
-  };
-} {
-  const { prefixes, idGenerator = defaultIdGenerator } = config;
-
-  const prefixedId = (modelName: ModelName): string | null => {
-    if (modelName in prefixes) {
-      return idGenerator(prefixes[modelName] as string);
-    }
-    return null;
-  };
-
-  return {
-    name: "prefixedIds",
-    query: {
-      $allModels: {
-        create: ({ args, query, model }: QueryArgs): Promise<any> => {
-          if (args.data && !args.data.id) {
-            const id = prefixedId(model as ModelName);
-            if (id) {
-              args.data.id = id;
-            }
-          }
-          return query(args);
-        },
-
-        createMany: ({ args, query, model }: QueryArgs): Promise<any> => {
-          if (model in prefixes && args.data && Array.isArray(args.data)) {
-            args.data = (args.data as Record<string, any>[]).map((item) => {
-              if (!item.id) {
-                const id = prefixedId(model as ModelName);
-                if (id) {
-                  return {
-                    ...item,
-                    id,
-                  };
-                }
-              }
-              return item;
-            });
-          }
-          return query(args);
-        },
-      },
-    },
-  };
-}
-
-export function extendPrismaClient<ModelName extends string = string>(
-  prisma: PrismaClient,
-  config: PrefixConfig<ModelName>,
-): PrismaClient {
-  return prisma.$extends(createPrefixedIdsExtension(config));
-}

package/tsconfig.json

@@ -1,15 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ES2020",
-    "module": "commonjs",
-    "declaration": true,
-    "outDir": "./dist",
-    "strict": true,
-    "esModuleInterop": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "moduleResolution": "node"
-  },
-  "include": ["src/**/*"],
-  "exclude": ["node_modules", "**/*.test.ts"]
-} 

package/tsconfig.test.json

@@ -1,11 +0,0 @@
-{
-  "extends": "./tsconfig.json",
-  "compilerOptions": {
-    "module": "commonjs",
-    "moduleResolution": "node",
-    "types": ["jest", "node"],
-    "esModuleInterop": true
-  },
-  "include": ["src/**/*.test.ts", "src/**/__tests__/**/*"],
-  "exclude": ["node_modules"]
-}