prisma-generator-express 1.18.0 → 1.19.0

package/dist/helpers/generateRouteFile.js

@@ -1,210 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.generateRouterFunction = generateRouterFunction;
-function generateRouterFunction({ model, }) {
-    const modelName = model.name;
-    const routerFunctionName = `${modelName}Router`;
-    return `import express, {
-  RequestHandler
-} from 'express'
-import { ParsedQs } from 'qs'
-import { ${modelName}FindFirst } from './${modelName}FindFirst';
-import { ${modelName}FindMany } from './${modelName}FindMany';
-import { ${modelName}FindUnique } from './${modelName}FindUnique';
-import { ${modelName}Create } from './${modelName}Create';
-import { ${modelName}CreateMany } from './${modelName}CreateMany';
-import { ${modelName}CreateManyAndReturn } from './${modelName}CreateManyAndReturn';
-import { ${modelName}Update } from './${modelName}Update';
-import { ${modelName}UpdateMany } from './${modelName}UpdateMany';
-import { ${modelName}UpdateManyAndReturn } from './${modelName}UpdateManyAndReturn';
-import { ${modelName}Upsert } from './${modelName}Upsert';
-import { ${modelName}Delete } from './${modelName}Delete';
-import { ${modelName}DeleteMany } from './${modelName}DeleteMany';
-import { ${modelName}Aggregate } from './${modelName}Aggregate';
-import { ${modelName}Count } from './${modelName}Count';
-import { ${modelName}GroupBy } from './${modelName}GroupBy';
-import { createValidatorMiddleware, removeTrailingSlash } from '../createValidatorMiddleware'
-import { RouteConfig, ValidatorConfig } from '../routeConfig'
-import { parseQueryParams } from "../parseQueryParams";
-
-const defaultBeforeAfter = {
-  before: [] as RequestHandler[],
-  after: [] as RequestHandler[],
-  inputValidator: undefined,
-  outputValidator: undefined,
-};
-
-/**
- * Generates an Express router for ${modelName} model.
- * @param config Contains optional middleware to enable routes.
- * @param customUrlPrefix Optional custom URL prefix for the routes.
- * @returns {express.Router}
- */
-export function ${routerFunctionName}(config: RouteConfig<RequestHandler>) {
-  const router = express.Router();
-  const basePath = removeTrailingSlash(config.customUrlPrefix || '') +
-                  removeTrailingSlash(config.addModelPrefix !== false ? '/${modelName.toLowerCase()}' : '');
-
-  const setupRoute = (
-    path: string,
-    method: "all" | "get" | "post" | "put" | "delete" | "patch" | "options" | "head",
-    middlewares: RequestHandler[],
-    handler: RequestHandler,
-    inputValidator?: ValidatorConfig,
-    outputValidator?: ValidatorConfig
-  ) => {
-    const middlewaresWithValidators: RequestHandler[] = [
-      (req, res, next) => {
-        if (req.query) {
-          req.query = parseQueryParams(req.query as Record<string, string>) as ParsedQs;
-        }
-        next();
-      },
-      ...middlewares
-    ];
-  
-    if (inputValidator) {
-      middlewaresWithValidators.push(createValidatorMiddleware({
-        schema: inputValidator.schema,
-        allowedPaths: inputValidator.allow,
-        forbiddenPaths: inputValidator.forbid,
-        target: method === 'get' ? 'query' : 'body',
-      }));
-    }
-  
-    middlewaresWithValidators.push((req, res, next) => {
-      res.locals.outputValidator = outputValidator;
-      next();
-    });
-  
-    middlewaresWithValidators.push(handler);
-  
-    router[method](removeTrailingSlash(basePath + path), ...middlewaresWithValidators);
-  };
-
-
-  if (config.enableAll || config?.findFirst) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.findFirst || defaultBeforeAfter;
-    setupRoute('/first', 'get', before, ${modelName}FindFirst as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/first', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.findMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.findMany || defaultBeforeAfter;
-    setupRoute('/', 'get', before, ${modelName}FindMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.findUnique) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.findUnique || defaultBeforeAfter;
-    setupRoute('/:id', 'get', before, ${modelName}FindUnique as any, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/:id', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.create) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.create || defaultBeforeAfter;
-    setupRoute('/', 'post', before, ${modelName}Create as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.createMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.createMany || defaultBeforeAfter;
-    setupRoute('/many', 'post', before, ${modelName}CreateMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.createManyAndReturn) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.createManyAndReturn || defaultBeforeAfter;
-    setupRoute('/many/return', 'post', before, ${modelName}CreateManyAndReturn as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many/return', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.update) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.update || defaultBeforeAfter;
-    setupRoute('/', 'put', before, ${modelName}Update as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.updateMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.updateMany || defaultBeforeAfter;
-    setupRoute('/many', 'put', before, ${modelName}UpdateMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.updateManyAndReturn) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.updateManyAndReturn || defaultBeforeAfter;
-    setupRoute('/many/return', 'put', before, ${modelName}UpdateManyAndReturn as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many/return', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.upsert) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.upsert || defaultBeforeAfter;
-    setupRoute('/', 'patch', before, ${modelName}Upsert as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.delete) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.delete || defaultBeforeAfter;
-    setupRoute('/', 'delete', before, ${modelName}Delete as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath + '/'), ...after);
-    }
-  }
-
-  if (config.enableAll || config?.deleteMany) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.deleteMany || defaultBeforeAfter;
-    setupRoute('/many', 'delete', before, ${modelName}DeleteMany as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/many', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.aggregate) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.aggregate || defaultBeforeAfter;
-    setupRoute('/aggregate', 'get', before, ${modelName}Aggregate as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/aggregate', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.count) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.count || defaultBeforeAfter;
-    setupRoute('/count', 'get', before, ${modelName}Count as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/count', ...after);
-    }
-  }
-
-  if (config.enableAll || config?.groupBy) {
-    const { before = [], after = [], inputValidator, outputValidator } = config.groupBy || defaultBeforeAfter;
-    setupRoute('/groupby', 'get', before, ${modelName}GroupBy as RequestHandler, inputValidator, outputValidator);
-    if (after.length) {
-      router.use(removeTrailingSlash(basePath) + '/groupby', ...after);
-    }
-  }
-
-  return router;
-}
-`;
-}
-//# sourceMappingURL=generateRouteFile.js.map

package/dist/helpers/generateRouteFile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"generateRouteFile.js","sourceRoot":"","sources":["../../src/helpers/generateRouteFile.ts"],"names":[],"mappings":";;AAEA,wDAkNC;AAlND,SAAgB,sBAAsB,CAAC,EACrC,KAAK,GAGN;IACC,MAAM,SAAS,GAAG,KAAK,CAAC,IAAI,CAAA;IAC5B,MAAM,kBAAkB,GAAG,GAAG,SAAS,QAAQ,CAAA;IAE/C,OAAO;;;;WAIE,SAAS,uBAAuB,SAAS;WACzC,SAAS,sBAAsB,SAAS;WACxC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,iCAAiC,SAAS;WACnD,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,iCAAiC,SAAS;WACnD,SAAS,oBAAoB,SAAS;WACtC,SAAS,oBAAoB,SAAS;WACtC,SAAS,wBAAwB,SAAS;WAC1C,SAAS,uBAAuB,SAAS;WACzC,SAAS,mBAAmB,SAAS;WACrC,SAAS,qBAAqB,SAAS;;;;;;;;;;;;;qCAab,SAAS;;;;;kBAK5B,kBAAkB;;;4EAGwC,SAAS,CAAC,WAAW,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;0CA0CzD,SAAS;;;;;;;;qCAQd,SAAS;;;;;;;;wCAQN,SAAS;;;;;;;;sCAQX,SAAS;;;;;;;;0CAQL,SAAS;;;;;;;;iDAQF,SAAS;;;;;;;;qCAQrB,SAAS;;;;;;;;yCAQL,SAAS;;;;;;;;gDAQF,SAAS;;;;;;;;uCAQlB,SAAS;;;;;;;;wCAQR,SAAS;;;;;;;;4CAQL,SAAS;;;;;;;;8CAQP,SAAS;;;;;;;;0CAQb,SAAS;;;;;;;;4CAQP,SAAS;;;;;;;;CAQpD,CAAA;AACD,CAAC"}

package/dist/utils/formatFile.js

@@ -1,26 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.formatFile = void 0;
-const prettier_1 = __importDefault(require("prettier"));
-const formatFile = (content) => {
-    return new Promise((res, rej) => prettier_1.default.resolveConfig(process.cwd()).then((options) => {
-        if (!options) {
-            res(content);
-        }
-        try {
-            const formatted = prettier_1.default.format(content, {
-                ...options,
-                parser: 'typescript',
-            });
-            res(formatted);
-        }
-        catch (error) {
-            rej(error);
-        }
-    }));
-};
-exports.formatFile = formatFile;
-//# sourceMappingURL=formatFile.js.map

package/dist/utils/formatFile.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"formatFile.js","sourceRoot":"","sources":["../../src/utils/formatFile.ts"],"names":[],"mappings":";;;;;;AAAA,wDAA+B;AAExB,MAAM,UAAU,GAAG,CAAC,OAAe,EAAmB,EAAE;IAC7D,OAAO,IAAI,OAAO,CAAC,CAAC,GAAG,EAAE,GAAG,EAAE,EAAE,CAC9B,kBAAQ,CAAC,aAAa,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,CAAC,IAAI,CAAC,CAAC,OAAO,EAAE,EAAE;QACrD,IAAI,CAAC,OAAO,EAAE,CAAC;YACb,GAAG,CAAC,OAAO,CAAC,CAAA;QACd,CAAC;QAED,IAAI,CAAC;YACH,MAAM,SAAS,GAAG,kBAAQ,CAAC,MAAM,CAAC,OAAO,EAAE;gBACzC,GAAG,OAAO;gBACV,MAAM,EAAE,YAAY;aACrB,CAAC,CAAA;YAEF,GAAG,CAAC,SAAS,CAAC,CAAA;QAChB,CAAC;QAAC,OAAO,KAAK,EAAE,CAAC;YACf,GAAG,CAAC,KAAK,CAAC,CAAA;QACZ,CAAC;IACH,CAAC,CAAC,CACH,CAAA;AACH,CAAC,CAAA;AAnBY,QAAA,UAAU,cAmBtB"}

package/src/bin.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-import './generator'

package/src/constants.ts

@@ -1 +0,0 @@
-export const GENERATOR_NAME = 'prisma-generator-express'

package/src/copy/encodeQueryParams.spec.ts

@@ -1,303 +0,0 @@
-import { encodeQueryParams } from './encodeQueryParams'
-
-describe('Query Params Encoding', () => {
-  it('should encode simple key-value pairs correctly', () => {
-    const params = {
-      id: 1,
-      name: 'test',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('id=1&name=test')
-  })
-
-  it('should encode nested objects correctly', () => {
-    const params = {
-      select: {
-        id: true,
-        name: true,
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('select%5Bid%5D=true&select%5Bname%5D=true')
-  })
-
-  it('should encode arrays correctly', () => {
-    const params = {
-      ids: [1, 2, 3],
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('ids%5B0%5D=1&ids%5B1%5D=2&ids%5B2%5D=3')
-  })
-
-  it('should encode complex nested objects correctly', () => {
-    const params = {
-      select: {
-        id: true,
-        project_id: true,
-        list_id: true,
-        user_assignments: {
-          select: {
-            user: true,
-          },
-        },
-        tags_mappings: {
-          select: {
-            tag: true,
-          },
-        },
-        attachments: {
-          select: {
-            attachment: true,
-          },
-          where: {
-            is_image: true,
-          },
-          take: 100,
-          orderBy: {
-            created_at: 'desc',
-          },
-        },
-        rendered_description: true,
-        description: true,
-        created_at: true,
-        start_date: true,
-        reactions: true,
-        intervals: true,
-        column_id: true,
-        priority: true,
-        due_date: true,
-        column: true,
-        title: true,
-        order: true,
-        color: true,
-      },
-      where: {
-        id: 'task_id',
-        AND: [
-          {
-            OR: [{ to_delete: false }, { to_delete: null }],
-          },
-        ],
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'select%5Bid%5D=true&select%5Bproject_id%5D=true&select%5Blist_id%5D=true&select%5Buser_assignments%5D%5Bselect%5D%5Buser%5D=true&select%5Btags_mappings%5D%5Bselect%5D%5Btag%5D=true&select%5Battachments%5D%5Bselect%5D%5Battachment%5D=true&select%5Battachments%5D%5Bwhere%5D%5Bis_image%5D=true&select%5Battachments%5D%5Btake%5D=100&select%5Battachments%5D%5BorderBy%5D%5Bcreated_at%5D=desc&select%5Brendered_description%5D=true&select%5Bdescription%5D=true&select%5Bcreated_at%5D=true&select%5Bstart_date%5D=true&select%5Breactions%5D=true&select%5Bintervals%5D=true&select%5Bcolumn_id%5D=true&select%5Bpriority%5D=true&select%5Bdue_date%5D=true&select%5Bcolumn%5D=true&select%5Btitle%5D=true&select%5Border%5D=true&select%5Bcolor%5D=true&where%5Bid%5D=task_id&where%5BAND%5D%5B0%5D%5BOR%5D%5B0%5D%5Bto_delete%5D=false&where%5BAND%5D%5B0%5D%5BOR%5D%5B1%5D%5Bto_delete%5D=null',
-    )
-  })
-
-  it('should handle empty objects correctly', () => {
-    const params = {}
-    const result = encodeQueryParams(params)
-    expect(result).toBe('')
-  })
-
-  it('should handle null values correctly', () => {
-    const params = {
-      id: null,
-      name: 'test',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('id=null&name=test')
-  })
-
-  it('should handle boolean values correctly', () => {
-    const params = {
-      isActive: true,
-      isDeleted: false,
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('isActive=true&isDeleted=false')
-  })
-
-  it('should handle nested arrays correctly', () => {
-    const params = {
-      filters: [
-        {
-          key: 'age',
-          values: [20, 30, 40],
-        },
-      ],
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'filters%5B0%5D%5Bkey%5D=age&filters%5B0%5D%5Bvalues%5D%5B0%5D=20&filters%5B0%5D%5Bvalues%5D%5B1%5D=30&filters%5B0%5D%5Bvalues%5D%5B2%5D=40',
-    )
-  })
-
-  it('should handle complex nested arrays and objects', () => {
-    const params = {
-      select: {
-        id: true,
-        name: true,
-        details: {
-          address: {
-            street: 'Main St',
-            city: 'Metropolis',
-          },
-          phoneNumbers: [
-            {
-              type: 'home',
-              number: '123-456-7890',
-            },
-            {
-              type: 'work',
-              number: '098-765-4321',
-            },
-          ],
-        },
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'select%5Bid%5D=true&select%5Bname%5D=true&select%5Bdetails%5D%5Baddress%5D%5Bstreet%5D=Main%20St&select%5Bdetails%5D%5Baddress%5D%5Bcity%5D=Metropolis&select%5Bdetails%5D%5BphoneNumbers%5D%5B0%5D%5Btype%5D=home&select%5Bdetails%5D%5BphoneNumbers%5D%5B0%5D%5Bnumber%5D=123-456-7890&select%5Bdetails%5D%5BphoneNumbers%5D%5B1%5D%5Btype%5D=work&select%5Bdetails%5D%5BphoneNumbers%5D%5B1%5D%5Bnumber%5D=098-765-4321',
-    )
-  })
-
-  it('should handle edge cases correctly', () => {
-    const params = {
-      select: {
-        id: '',
-        name: null,
-        details: {
-          address: {
-            street: undefined,
-            city: 'Metropolis',
-          },
-        },
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'select%5Bid%5D=&select%5Bname%5D=null&select%5Bdetails%5D%5Baddress%5D%5Bcity%5D=Metropolis',
-    )
-  })
-
-  it('should handle multiple nested levels correctly', () => {
-    const params = {
-      level1: {
-        level2: {
-          level3: {
-            level4: {
-              key: 'value',
-            },
-          },
-        },
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'level1%5Blevel2%5D%5Blevel3%5D%5Blevel4%5D%5Bkey%5D=value',
-    )
-  })
-
-  it('should handle empty strings and null values correctly', () => {
-    const params = {
-      key1: '',
-      key2: null,
-      key3: 'value',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('key1=&key2=null&key3=value')
-  })
-
-  it('should encode special characters correctly', () => {
-    const params = {
-      name: "O'Reilly & Sons",
-      description: '20% discount!',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'name=O%27Reilly%20%26%20Sons&description=20%25%20discount%21',
-    )
-  })
-
-  it('should handle empty arrays correctly', () => {
-    const params = {
-      filters: [],
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('filters%5B%5D=')
-  })
-
-  it('should encode only special characters correctly', () => {
-    const params = {
-      special: '!@#$%^&*()_+{}|:"<>?[]\\;\',./`~',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'special=%21%40%23%24%25%5E%26%2A%28%29_%2B%7B%7D%7C%3A%22%3C%3E%3F%5B%5D%5C%3B%27%2C.%2F%60%7E',
-    )
-  })
-
-  it('should encode repeated special characters correctly', () => {
-    const params = {
-      special: '!!!@@@###$$$',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('special=%21%21%21%40%40%40%23%23%23%24%24%24')
-  })
-
-  it('should encode special characters in keys correctly', () => {
-    const params = {
-      'sp!ci@l': 'value',
-      'key&with=special?chars': 'another value',
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'sp%21ci%40l=value&key%26with%3Dspecial%3Fchars=another%20value',
-    )
-  })
-
-  it('should handle arrays with mixed types correctly', () => {
-    const params = {
-      mixedArray: [1, 'two', { three: 3 }],
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'mixedArray%5B0%5D=1&mixedArray%5B1%5D=two&mixedArray%5B2%5D%5Bthree%5D=3',
-    )
-  })
-
-  it('should handle boolean and null values in nested objects correctly', () => {
-    const params = {
-      nested: {
-        flag: true,
-        notSet: null,
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe('nested%5Bflag%5D=true&nested%5BnotSet%5D=null')
-  })
-
-  it('should handle empty strings in nested objects correctly', () => {
-    const params = {
-      nested: {
-        emptyString: '',
-        validString: 'value',
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'nested%5BemptyString%5D=&nested%5BvalidString%5D=value',
-    )
-  })
-
-  it('should handle deeply nested structures correctly', () => {
-    const params = {
-      level1: {
-        level2: {
-          level3: {
-            level4: {
-              level5: 'value',
-            },
-          },
-        },
-      },
-    }
-    const result = encodeQueryParams(params)
-    expect(result).toBe(
-      'level1%5Blevel2%5D%5Blevel3%5D%5Blevel4%5D%5Blevel5%5D=value',
-    )
-  })
-})

package/src/copy/encodeQueryParams.ts

@@ -1,44 +0,0 @@
-import { isObject } from './misc'
-
-/**
- * Encodes query parameters recursively, skipping undefined values.
- * @param {Record<string, unknown>} params - The query parameters to encode.
- * @returns {string} The encoded query string.
- */
-export const encodeQueryParams = (params: Record<string, unknown>): string => {
-  const customEncodeURIComponent = (str: string): string => {
-    return encodeURIComponent(str)
-      .replace(
-        /[!'()*~]/g,
-        (c) => `%${c.charCodeAt(0).toString(16).toUpperCase()}`,
-      )
-      .replace(/%20/g, '%20') // Encode spaces as %20
-  }
-
-  const encode = (key: string, value: unknown): string => {
-    if (value === undefined) {
-      return ''
-    }
-    if (Array.isArray(value)) {
-      if (value.length === 0) {
-        return `${customEncodeURIComponent(key)}%5B%5D=`
-      }
-      return value
-        .map((v, i) => encode(`${key}[${i}]`, v))
-        .filter(Boolean)
-        .join('&')
-    }
-    if (isObject(value)) {
-      return Object.entries(value)
-        .map(([k, v]) => encode(`${key}[${k}]`, v))
-        .filter(Boolean)
-        .join('&')
-    }
-    return `${customEncodeURIComponent(key)}=${customEncodeURIComponent(String(value))}`
-  }
-
-  return Object.entries(params)
-    .map(([k, v]) => encode(k, v))
-    .filter(Boolean)
-    .join('&')
-}

package/src/copy/misc.spec.ts

@@ -1,62 +0,0 @@
-import { isJsonString, safeJSONparse, isObject } from './misc'
-
-describe('misc.ts', () => {
-  describe('isJsonString', () => {
-    it('should return true for valid JSON string', () => {
-      expect(isJsonString('{"name":"John"}')).toBe(true)
-    })
-
-    it('should return false for invalid JSON string', () => {
-      expect(isJsonString('{"name": "John"')).toBe(false) // Missing closing brace
-    })
-
-    it('should return false for non-string input', () => {
-      expect(isJsonString(123)).toBe(false)
-      expect(isJsonString({ name: 'John' })).toBe(false)
-      expect(isJsonString(null)).toBe(false)
-      expect(isJsonString(undefined)).toBe(false)
-    })
-  })
-  describe('safeJSONparse', () => {
-    it('should parse valid JSON string', () => {
-      expect(safeJSONparse('{"name":"John"}')).toEqual({ name: 'John' })
-    })
-
-    it('should return false for string "false"', () => {
-      expect(safeJSONparse('false')).toBe(false)
-    })
-
-    it('should return undefined for string "undefined"', () => {
-      expect(safeJSONparse('undefined')).toBeUndefined()
-    })
-
-    it('should return null for string "null"', () => {
-      expect(safeJSONparse('null')).toBeNull()
-    })
-
-    it('should return original data for non-JSON string', () => {
-      expect(safeJSONparse('Hello World')).toBe('Hello World')
-    })
-
-    it('should return original data for non-string input', () => {
-      expect(safeJSONparse(123)).toBe(123)
-      expect(safeJSONparse({ name: 'John' })).toEqual({ name: 'John' })
-      expect(safeJSONparse(null)).toBe(null)
-      expect(safeJSONparse(undefined)).toBe(undefined)
-    })
-  })
-  describe('isObject', () => {
-    it('should return true for objects', () => {
-      expect(isObject({})).toBe(true)
-      expect(isObject({ name: 'John' })).toBe(true)
-    })
-
-    it('should return false for non-objects', () => {
-      expect(isObject('Hello World')).toBe(false)
-      expect(isObject(123)).toBe(false)
-      expect(isObject(null)).toBe(false)
-      expect(isObject(undefined)).toBe(false)
-      expect(isObject([])).toBe(false) // Arrays are not considered objects in this context
-    })
-  })
-})