vms-nest-api-document 1.0.0

package/dist/zod_utils/zod_utils.js

@@ -0,0 +1,425 @@
+// src/zod_utils/zod_utils.ts
+import { z } from "zod";
+
+// src/core/BaseResponse.ts
+var r_log = (data = {}) => {
+  return data;
+};
+
+// src/zod_utils/zod_utils.ts
+var handleNullOrUndefined = (value) => typeof value === "string" ? value : "";
+var stringUUIDMandatory = (fieldName) => {
+  const schema = z.string().trim().uuid({ message: `${fieldName} must be a valid UUID` }).nonempty(`${fieldName} is required.`).transform(handleNullOrUndefined);
+  return schema;
+};
+var stringMandatory = (fieldName, min = 1, max = 100) => {
+  const schema = z.string().trim().min(min, `${fieldName} must be at least ${min} characters.`).max(max, `${fieldName} must be at most ${max} characters.`).nonempty(`${fieldName} is required.`).transform(handleNullOrUndefined);
+  return schema;
+};
+var stringOptional = (fieldName, min = 0, max = 255, defaultValue = "") => {
+  const schema = z.string().trim().min(min, `${fieldName} must be at least ${min} characters.`).max(max, `${fieldName} must be at most ${max} characters.`).transform(handleNullOrUndefined).default(defaultValue);
+  return schema;
+};
+var handleNullOrUndefinedStringArray = (value, defaultValue) => Array.isArray(value) ? value : defaultValue;
+var stringArrayMandatory = (fieldName, min = 1, max = 100, unique = false) => {
+  const schema = z.array(z.string().trim(), {
+    invalid_type_error: `${fieldName} must be an array of strings.`
+  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
+  if (unique) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  return schema.transform((val) => handleNullOrUndefinedStringArray(val, []));
+};
+var stringArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], unique = false) => {
+  const schema = z.array(z.string().trim(), {
+    invalid_type_error: `${fieldName} must be an array of strings.`
+  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
+  if (unique) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  return schema.optional().default(defaultValue);
+};
+var numberMandatory = (fieldName, min = 1, max = 1e14, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => {
+      if (val === null || val === void 0 || val === "") {
+        return defaultValue;
+      }
+      if (typeof val === "string" && !isNaN(Number(val))) {
+        return Number(val);
+      }
+      return val;
+    },
+    z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`)
+  );
+};
+var numberOptional = (fieldName, min = 0, max = 1e14, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => typeof val === "string" && val.trim() !== "" ? Number(val) : val,
+    z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`).optional().default(defaultValue)
+  );
+};
+var handleNullOrUndefinedNumberArray = (value, defaultValue) => Array.isArray(value) ? value : defaultValue;
+var numberArrayMandatory = (fieldName, min = 1, max = 100, unique = false) => {
+  const schema = z.array(
+    z.number({
+      invalid_type_error: `${fieldName} must be an array of numbers.`
+    })
+  ).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
+  if (unique) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  return schema.transform((val) => handleNullOrUndefinedNumberArray(val, []));
+};
+var numberArrayOptional = (fieldName, min = 0, max = 100, defaultValue = [], unique = false) => {
+  const schema = z.array(
+    z.number({
+      invalid_type_error: `${fieldName} must be an array of numbers.`
+    })
+  ).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
+  if (unique) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  return schema.optional().default(defaultValue);
+};
+var doubleMandatory = (fieldName, min = 0.1, max = 1e6, decimalPlaces = 2, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => {
+      if (typeof val === "string") {
+        val = parseFloat(val);
+      }
+      if (typeof val === "number") {
+        return parseFloat(val.toFixed(decimalPlaces));
+      }
+      return val;
+    },
+    z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`).default(defaultValue)
+  );
+};
+var doubleMandatoryLatLng = (fieldName, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => {
+      if (typeof val === "string") {
+        val = parseFloat(val);
+      }
+      if (typeof val === "number") {
+        return parseFloat(val.toFixed(6));
+      }
+      return val;
+    },
+    z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(-180, `${fieldName} must be at least -180.`).max(180, `${fieldName} must be at most 180.`).default(defaultValue)
+  );
+};
+var doubleMandatoryAmount = (fieldName, defaultValue = 0) => {
+  return z.preprocess((val) => {
+    if (typeof val === "string") {
+      val = parseFloat(val);
+    }
+    if (typeof val === "number") {
+      return parseFloat(val.toFixed(6));
+    }
+    return val;
+  }, z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue));
+};
+var doubleOptional = (fieldName, min = 0, max = 1e6, decimalPlaces = 2, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => {
+      if (typeof val === "string") {
+        val = parseFloat(val);
+      }
+      if (typeof val === "number") {
+        return parseFloat(val.toFixed(decimalPlaces));
+      }
+      return val;
+    },
+    z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(min, `${fieldName} must be at least ${min}.`).max(max, `${fieldName} must be at most ${max}.`).default(defaultValue)
+  ).optional();
+};
+var doubleOptionalLatLng = (fieldName, defaultValue = 0) => {
+  return z.preprocess(
+    (val) => {
+      if (typeof val === "string") {
+        val = parseFloat(val);
+      }
+      if (typeof val === "number") {
+        return parseFloat(val.toFixed(6));
+      }
+      return val;
+    },
+    z.number({ invalid_type_error: `${fieldName} must be a number.` }).min(-180, `${fieldName} must be at least -180.`).max(180, `${fieldName} must be at most 180.`).default(defaultValue)
+  ).optional();
+};
+var doubleOptionalAmount = (fieldName, defaultValue = 0) => {
+  return z.preprocess((val) => {
+    if (typeof val === "string") {
+      val = parseFloat(val);
+    }
+    if (typeof val === "number") {
+      return parseFloat(val.toFixed(6));
+    }
+    return val;
+  }, z.number({ invalid_type_error: `${fieldName} must be a number.` }).default(defaultValue)).optional();
+};
+var handleNullOrUndefinedBoolean = (value, defaultValue) => typeof value === "boolean" ? value : defaultValue;
+var booleanMandatory = (fieldName, defaultValue = false) => {
+  return z.boolean({ invalid_type_error: `${fieldName} must be true or false.` }).transform((val) => handleNullOrUndefinedBoolean(val, defaultValue));
+};
+var booleanOptional = (fieldName, defaultValue = false) => {
+  return z.boolean({ invalid_type_error: `${fieldName} must be true or false.` }).optional().default(defaultValue);
+};
+var enumMandatory = (fieldName, enumType, defaultValue) => {
+  return z.union([
+    z.nativeEnum(enumType, {
+      invalid_type_error: `${fieldName} should be one of the following values: ${Object.values(
+        enumType
+      ).join(", ")}.`
+    }),
+    z.string().refine((val) => Object.values(enumType).includes(val), {
+      message: `${fieldName} should be one of the following values: ${Object.values(
+        enumType
+      ).join(", ")}.`
+    })
+  ]).default(defaultValue).refine((val) => val !== "", {
+    message: `Please select ${fieldName}.`
+  });
+};
+var enumOptional = (fieldName, enumType, defaultValue) => {
+  return z.nativeEnum(enumType, {
+    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
+      enumType
+    ).join(", ")}.`
+  }).optional().default(() => defaultValue);
+};
+var handleNullOrUndefinedEnumArray = (value, defaultValue) => Array.isArray(value) ? value : defaultValue;
+var getAllEnums = (enumType) => {
+  return Object.values(enumType);
+};
+var enumArrayMandatory = (fieldName, enumType, defaultValue = getAllEnums(enumType), min = 1, max = 100, unique = false) => {
+  const schema = z.array(z.nativeEnum(enumType), {
+    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
+      enumType
+    ).join(", ")}.`
+  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
+  if (unique) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  schema.transform((val) => handleNullOrUndefinedEnumArray(val, []));
+  return schema.default(() => defaultValue);
+};
+var enumArrayOptional = (fieldName, enumType, defaultValue = getAllEnums(enumType), min = 0, max = 100, unique = false) => {
+  const schema = z.array(z.nativeEnum(enumType), {
+    invalid_type_error: `${fieldName} must be an array containing only the following values: ${Object.values(
+      enumType
+    ).join(", ")}.`
+  }).min(min, `${fieldName} must contain at least ${min} items.`).max(max, `${fieldName} must contain at most ${max} items.`);
+  if (unique) {
+    schema.refine(
+      (arr) => new Set(arr).size === arr.length,
+      `${fieldName} must contain unique values.`
+    );
+  }
+  return schema.optional().default(() => defaultValue);
+};
+var handleNullOrUndefinedDate = (value, defaultValue) => {
+  if (typeof value === "string" && !isNaN(Date.parse(value))) {
+    return value;
+  }
+  return defaultValue;
+};
+var dateMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
+  const schema = z.string().refine((val) => val !== "" && val !== null && val !== void 0, {
+    message: `Please select ${fieldName}.`
+  }).refine((val) => !isNaN(Date.parse(val)), {
+    message: `${fieldName} must be a valid ISO date.`
+  }).refine((val) => !minDate || new Date(val) >= new Date(minDate), {
+    message: `${fieldName} must be after ${minDate}.`
+  }).refine((val) => !maxDate || new Date(val) <= new Date(maxDate), {
+    message: `${fieldName} must be before ${maxDate}.`
+  }).transform((val) => handleNullOrUndefinedDate(val, defaultValue));
+  return schema;
+};
+var dateOptional = (fieldName, minDate, maxDate) => {
+  const base = z.string();
+  const refinements = [
+    {
+      check: (val) => !val.trim() || !isNaN(Date.parse(val)),
+      message: `${fieldName} must be a valid ISO date.`
+    }
+  ];
+  if (minDate) {
+    refinements.push({
+      check: (val) => !val.trim() || new Date(val) >= new Date(minDate),
+      message: `${fieldName} must be after ${minDate}.`
+    });
+  }
+  if (maxDate) {
+    refinements.push({
+      check: (val) => !val.trim() || new Date(val) <= new Date(maxDate),
+      message: `${fieldName} must be before ${maxDate}.`
+    });
+  }
+  let refined = base;
+  for (const { check, message } of refinements) {
+    refined = refined.refine(check, { message });
+  }
+  return refined.optional().default("");
+};
+var dateTimeMandatory = (fieldName, minDate, maxDate, defaultValue = (/* @__PURE__ */ new Date()).toISOString()) => {
+  const schema = z.string().refine((val) => !isNaN(Date.parse(val)), {
+    message: `${fieldName} must be a valid ISO date.`
+  }).transform((val) => handleNullOrUndefinedDate(val, defaultValue));
+  if (minDate) {
+    schema.refine((val) => new Date(val) >= new Date(minDate), {
+      message: `${fieldName} must be after ${minDate}.`
+    });
+  }
+  if (maxDate) {
+    schema.refine((val) => new Date(val) <= new Date(maxDate), {
+      message: `${fieldName} must be before ${maxDate}.`
+    });
+  }
+  return schema;
+};
+var dateTimeOptional = (fieldName, minDate, maxDate) => {
+  const base = z.string();
+  const refinements = [
+    {
+      check: (val) => !val.trim() || !isNaN(Date.parse(val)),
+      message: `${fieldName} must be a valid ISO date time.`
+    }
+  ];
+  if (minDate) {
+    refinements.push({
+      check: (val) => !val.trim() || new Date(val) >= new Date(minDate),
+      message: `${fieldName} must be after ${minDate}.`
+    });
+  }
+  if (maxDate) {
+    refinements.push({
+      check: (val) => !val.trim() || new Date(val) <= new Date(maxDate),
+      message: `${fieldName} must be before ${maxDate}.`
+    });
+  }
+  let refined = base;
+  for (const { check, message } of refinements) {
+    refined = refined.refine(check, { message });
+  }
+  return refined.optional().default("");
+};
+var nestedObjectMandatory = (fieldName, schema, defaultValue) => {
+  return schema.default(() => defaultValue);
+};
+var nestedObjectOptional = (fieldName, schema, defaultValue) => {
+  return schema.optional().default(() => defaultValue);
+};
+var dynamicJsonSchema = (fieldName, defaultValue = {}) => z.record(z.any()).optional().default(() => defaultValue);
+var nestedArrayOfObjectMandatory = (fieldName, schema, defaultValue = [], min = 1, max) => {
+  let arraySchema = z.array(schema, {
+    invalid_type_error: `${fieldName} must be an array of objects.`
+  }).min(min, `${fieldName} must contain at least ${min} items.`);
+  if (max !== void 0) {
+    arraySchema = arraySchema.max(
+      max,
+      `${fieldName} must contain at most ${max} items.`
+    );
+  }
+  return arraySchema.default(() => defaultValue);
+};
+var nestedArrayOfObjectsOptional = (fieldName, schema, defaultValue = [], min = 0, max) => {
+  let arraySchema = z.array(schema, {
+    invalid_type_error: `${fieldName} must be an array of objects.`
+  }).min(min, `${fieldName} must contain at least ${min} items.`);
+  if (max !== void 0) {
+    arraySchema = arraySchema.max(
+      max,
+      `${fieldName} must contain at most ${max} items.`
+    );
+  }
+  return arraySchema.optional().default(() => defaultValue);
+};
+var single_select_mandatory = (fieldName) => {
+  const schema = z.string().trim().nonempty(`Please select ${fieldName}.`).transform(handleNullOrUndefined);
+  return schema;
+};
+var single_select_optional = (fieldName) => {
+  r_log(fieldName);
+  const schema = z.string().trim().transform(handleNullOrUndefined);
+  return schema;
+};
+var multi_select_mandatory = (fieldName, min = 1, max = 100, defaultValue = []) => {
+  const schema = z.array(
+    z.string({
+      invalid_type_error: `${fieldName} must be an array of strings.`
+    })
+  ).min(
+    min,
+    `Please select at least ${min} ${fieldName}${min > 1 ? "s" : ""}.`
+  ).max(
+    max,
+    `Please select at most ${max} ${fieldName}${max > 1 ? "s" : ""}.`
+  );
+  return schema.optional().default(defaultValue);
+};
+var multi_select_optional = (fieldName, max = 1e3, defaultValue = []) => {
+  const schema = z.array(
+    z.string({
+      invalid_type_error: `${fieldName} must be an array of strings.`
+    })
+  ).max(
+    max,
+    `Please select at most ${max} ${fieldName}${max > 1 ? "s" : ""}.`
+  );
+  return schema.optional().default(defaultValue);
+};
+export {
+  booleanMandatory,
+  booleanOptional,
+  dateMandatory,
+  dateOptional,
+  dateTimeMandatory,
+  dateTimeOptional,
+  doubleMandatory,
+  doubleMandatoryAmount,
+  doubleMandatoryLatLng,
+  doubleOptional,
+  doubleOptionalAmount,
+  doubleOptionalLatLng,
+  dynamicJsonSchema,
+  enumArrayMandatory,
+  enumArrayOptional,
+  enumMandatory,
+  enumOptional,
+  getAllEnums,
+  multi_select_mandatory,
+  multi_select_optional,
+  nestedArrayOfObjectMandatory,
+  nestedArrayOfObjectsOptional,
+  nestedObjectMandatory,
+  nestedObjectOptional,
+  numberArrayMandatory,
+  numberArrayOptional,
+  numberMandatory,
+  numberOptional,
+  single_select_mandatory,
+  single_select_optional,
+  stringArrayMandatory,
+  stringArrayOptional,
+  stringMandatory,
+  stringOptional,
+  stringUUIDMandatory
+};

package/package.json

@@ -0,0 +1,80 @@
+{
+  "name": "vms-nest-api-document",
+  "version": "1.0.0",
+  "description": "Reusable API SDK built with NestJS, Prisma, Axios, and Zod for VMS frontends.",
+  "main": "dist/index.js",
+  "module": "dist/index.mjs",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "lint": "eslint . --ext .ts",
+    "format": "prettier --write .",
+    "prepublishOnly": "npm run build"
+  },
+  "repository": "https://github.com/acvtechp/vms_nest_api_document",
+  "bugs": "https://github.com/acvtechp/vms_nest_api_document/issues",
+  "homepage": "https://github.com/acvtechp/vms_nest_api_document#readme",
+  "keywords": [
+    "nestjs",
+    "prisma",
+    "sdk",
+    "api",
+    "axios",
+    "zod",
+    "typescript",
+    "frontend",
+    "react",
+    "nextjs"
+  ],
+  "author": "RamkiTech",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.mjs",
+      "require": "./dist/index.js"
+    },
+    "./services/*": {
+      "import": "./dist/services/*",
+      "require": "./dist/services/*"
+    },
+    "./core/*": {
+      "import": "./dist/core/*",
+      "require": "./dist/core/*"
+    },
+    "./zod_utils/*": {
+      "import": "./dist/zod_utils/*",
+      "require": "./dist/zod_utils/*"
+    }
+  },
+  "typesVersions": {
+    "*": {
+      "services/*": [
+        "dist/services/*"
+      ],
+      "core/*": [
+        "dist/core/*"
+      ],
+      "zod_utils/*": [
+        "dist/zod_utils/*"
+      ]
+    }
+  },
+  "type": "module",
+  "dependencies": {
+    "axios": "^1.11.0",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "eslint": "^9.31.0",
+    "eslint-config-next": "^15.4.3",
+    "prettier": "^3.6.2",
+    "tsup": "^8.5.0",
+    "typescript": "^5.8.3"
+  }
+}