@treatwell/moleculer-essentials 1.0.0

package/dist/index-rZl77S1z.cjs

@@ -0,0 +1,375 @@
+'use strict';
+
+var lodash = require('lodash');
+var v4 = require('zod/v4');
+var bson = require('bson');
+var dateFns = require('date-fns');
+var zod = require('zod');
+
+const COERCE_ARRAY_ATTRIBUTE = "x-coerce-array";
+const SCHEMA_REF_NAME = "$id";
+const EMPTY_OBJECT_SCHEMA = {
+  type: "object",
+  additionalProperties: true,
+  required: [],
+  properties: {}
+};
+const DATE_TYPE = {
+  type: "string",
+  format: "date-time"
+};
+const OBJECTID_TYPE = {
+  type: "string",
+  pattern: "^[0-9A-Fa-f]{24}$",
+  format: "object-id",
+  description: "ObjectId"
+};
+
+function omitFields(schema, fields, refName) {
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    return {
+      ...schema,
+      [SCHEMA_REF_NAME]: refName,
+      anyOf: schema.anyOf?.map(
+        (s) => omitFields(s, fields)
+      ),
+      allOf: schema.allOf?.map(
+        (s) => omitFields(s, fields)
+      ),
+      oneOf: schema.oneOf?.map(
+        (s) => omitFields(s, fields)
+      )
+    };
+  }
+  return {
+    ...schema,
+    [SCHEMA_REF_NAME]: refName,
+    required: schema.required.filter((f) => !fields.includes(f)),
+    properties: lodash.omit(schema.properties, fields)
+  };
+}
+function pickFields(schema, fields, refName) {
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    return {
+      ...schema,
+      [SCHEMA_REF_NAME]: refName,
+      anyOf: schema.anyOf?.map(
+        (s) => pickFields(s, fields)
+      ),
+      allOf: schema.allOf?.map(
+        (s) => pickFields(s, fields)
+      ),
+      oneOf: schema.oneOf?.map(
+        (s) => pickFields(s, fields)
+      )
+    };
+  }
+  return {
+    ...schema,
+    [SCHEMA_REF_NAME]: refName,
+    required: schema.required.filter((f) => fields.includes(f)),
+    properties: lodash.pick(schema.properties, fields)
+  };
+}
+function optionalExceptFields(schema, fields, refName) {
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    return {
+      ...schema,
+      [SCHEMA_REF_NAME]: refName,
+      anyOf: schema.anyOf?.map(
+        (s) => optionalExceptFields(s, fields)
+      ),
+      allOf: schema.allOf?.map(
+        (s) => optionalExceptFields(s, fields)
+      ),
+      oneOf: schema.oneOf?.map(
+        (s) => optionalExceptFields(s, fields)
+      )
+    };
+  }
+  return {
+    ...schema,
+    [SCHEMA_REF_NAME]: refName,
+    required: schema.required.filter((f) => fields.includes(f))
+  };
+}
+function optionalFields(schema, fields, refName) {
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    return {
+      ...schema,
+      [SCHEMA_REF_NAME]: refName,
+      anyOf: schema.anyOf?.map(
+        (s) => optionalFields(s, fields)
+      ),
+      allOf: schema.allOf?.map(
+        (s) => optionalFields(s, fields)
+      ),
+      oneOf: schema.oneOf?.map(
+        (s) => optionalFields(s, fields)
+      )
+    };
+  }
+  return {
+    ...schema,
+    [SCHEMA_REF_NAME]: refName,
+    required: schema.required.filter((f) => !fields.includes(f))
+  };
+}
+function toPartialSchema(schema, refName) {
+  if (schema.anyOf || schema.allOf || schema.oneOf) {
+    return {
+      ...schema,
+      [SCHEMA_REF_NAME]: refName,
+      anyOf: schema.anyOf?.map(
+        (s) => toPartialSchema(s)
+      ),
+      allOf: schema.allOf?.map(
+        (s) => toPartialSchema(s)
+      ),
+      oneOf: schema.oneOf?.map(
+        (s) => toPartialSchema(s)
+      )
+    };
+  }
+  return {
+    ...schema,
+    [SCHEMA_REF_NAME]: refName,
+    required: []
+  };
+}
+function addFieldsToSchema(schema, newFields, refName) {
+  return {
+    ...schema,
+    [SCHEMA_REF_NAME]: refName,
+    properties: { ...schema.properties, ...newFields }
+  };
+}
+function composeSchemas(schemaRefName, ...schemas) {
+  return {
+    [SCHEMA_REF_NAME]: schemaRefName ?? void 0,
+    type: "object",
+    required: [],
+    unevaluatedProperties: false,
+    allOf: schemas
+  };
+}
+
+function deepRefReplacer(obj, extractor, currentId = "") {
+  if (!obj || typeof obj !== "object") {
+    return;
+  }
+  if ("$ref" in obj && typeof obj.$ref === "string") {
+    let id;
+    if (obj.$ref === "#") {
+      if (!currentId) {
+        throw new Error("Got a recursive ref (#) without a parent id.");
+      }
+      id = currentId;
+    } else if (obj.$ref.startsWith("#/$defs/")) {
+      id = obj.$ref.replace("#/$defs/", "");
+    }
+    if (id) {
+      obj.$ref = extractor.refReplacer(id);
+    }
+  } else {
+    for (const val of Object.values(obj)) {
+      deepRefReplacer(val, extractor, currentId);
+    }
+  }
+}
+function zodToOpenAPISchema(schema, extractor) {
+  const res = zod.z.toJSONSchema(schema, {
+    io: "input",
+    unrepresentable: "any",
+    override: ({ zodSchema, jsonSchema }) => {
+      const { def } = zodSchema._zod;
+      if (def.type === "date") {
+        jsonSchema.type = "string";
+        jsonSchema.format = "date-time";
+      }
+      if (def.type === "custom" && def.fn === isObjectId) {
+        jsonSchema.type = "string";
+        jsonSchema.format = "object-id";
+        jsonSchema.pattern = "^[0-9A-Fa-f]{24}$";
+      }
+      if (Object.keys(jsonSchema).length === 0) {
+        throw new Error(
+          `Zod schema ${def.type} is not representable in OpenAPI.`
+        );
+      }
+      if (jsonSchema.id) {
+        jsonSchema.$id = jsonSchema.id;
+        delete jsonSchema.id;
+      }
+    }
+  });
+  deepRefReplacer(res, extractor, res.$id);
+  if (res.$defs) {
+    for (const [key, val] of Object.entries(res.$defs)) {
+      deepRefReplacer(val, extractor, key);
+      extractor.onNewRef(key, val);
+    }
+    delete res.$defs;
+  }
+  delete res.$schema;
+  if (res.$id) {
+    extractor.onNewRef(res.$id, res);
+    return { $ref: extractor.refReplacer(res.$id) };
+  }
+  return res;
+}
+const zodDate = zod.z.transform((val) => {
+  if (typeof val === "string") {
+    const date = dateFns.parseISO(val);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return val;
+}).pipe(zod.z.date());
+const OBJECT_ID_PATTERN = /^[a-f\d]{24}$/i;
+function isObjectId(val) {
+  return val instanceof bson.ObjectId;
+}
+const zodObjectId = zod.z.transform((val) => {
+  if (typeof val === "string" && OBJECT_ID_PATTERN.test(val)) {
+    return new bson.ObjectId(val);
+  }
+  return val;
+}).pipe(zod.z.custom(isObjectId, { abort: true })).meta({ id: "ObjectId" });
+function zodCoerceArray(element, params) {
+  return zod.z.transform((val) => !Array.isArray(val) && val !== void 0 ? [val] : val).pipe(zod.z.array(element, params));
+}
+
+const ServerErrorSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: {
+    name: { type: "string" },
+    stack: { type: "string", nullable: true },
+    type: { type: "string" },
+    data: { type: "object", nullable: true },
+    message: { type: "string" },
+    code: { type: "integer" },
+    retryable: { type: "boolean" }
+  },
+  example: {
+    name: "MoleculerServerError",
+    message: "Internal Server Error",
+    code: 500
+  }
+};
+const UnauthorizedErrorSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: {},
+  example: {
+    name: "UnAuthorizedError",
+    message: "Unauthorized",
+    code: 401,
+    type: "NO_TOKEN",
+    data: null
+  }
+};
+const FileNotExistSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: {},
+  example: {
+    name: "MoleculerClientError",
+    message: "File missing in the request",
+    code: 400
+  }
+};
+const FileTooBigSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: {},
+  example: {
+    name: "PayloadTooLarge",
+    message: "Payload too large",
+    code: 413,
+    type: "PAYLOAD_TOO_LARGE",
+    data: {
+      fieldname: "file",
+      filename: "4b2005c0b8.png",
+      encoding: "7bit",
+      mimetype: "image/png"
+    }
+  }
+};
+const ValidationErrorSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: ServerErrorSchema.properties,
+  example: {
+    code: 422,
+    type: "VALIDATION_ERROR",
+    data: [
+      {
+        keyword: "additionalProperties",
+        dataPath: "",
+        schemaPath: "#/additionalProperties",
+        params: {
+          additionalProperty: "originalDate"
+        },
+        message: "should NOT have additional properties"
+      }
+    ]
+  }
+};
+const GetOpenApiParamsSchema = {
+  type: "object",
+  additionalProperties: false,
+  required: [],
+  properties: { kind: { type: "string" } }
+};
+
+function createOpenAPIResponses(model, description = "") {
+  const isZodType = model instanceof v4.z.ZodType;
+  return {
+    responses: {
+      "200": {
+        description,
+        content: {
+          "application/json": {
+            // @ts-expect-error Moleculer will clone this object using lodash,
+            // losing the zod class instance. By using a function, we ensure
+            // that clone doesn't break the zod instance
+            zodInstance: isZodType ? () => model : void 0,
+            schema: isZodType ? void 0 : model
+          }
+        }
+      }
+    }
+  };
+}
+
+exports.COERCE_ARRAY_ATTRIBUTE = COERCE_ARRAY_ATTRIBUTE;
+exports.DATE_TYPE = DATE_TYPE;
+exports.EMPTY_OBJECT_SCHEMA = EMPTY_OBJECT_SCHEMA;
+exports.FileNotExistSchema = FileNotExistSchema;
+exports.FileTooBigSchema = FileTooBigSchema;
+exports.GetOpenApiParamsSchema = GetOpenApiParamsSchema;
+exports.OBJECTID_TYPE = OBJECTID_TYPE;
+exports.SCHEMA_REF_NAME = SCHEMA_REF_NAME;
+exports.ServerErrorSchema = ServerErrorSchema;
+exports.UnauthorizedErrorSchema = UnauthorizedErrorSchema;
+exports.ValidationErrorSchema = ValidationErrorSchema;
+exports.addFieldsToSchema = addFieldsToSchema;
+exports.composeSchemas = composeSchemas;
+exports.createOpenAPIResponses = createOpenAPIResponses;
+exports.omitFields = omitFields;
+exports.optionalExceptFields = optionalExceptFields;
+exports.optionalFields = optionalFields;
+exports.pickFields = pickFields;
+exports.toPartialSchema = toPartialSchema;
+exports.zodCoerceArray = zodCoerceArray;
+exports.zodDate = zodDate;
+exports.zodObjectId = zodObjectId;
+exports.zodToOpenAPISchema = zodToOpenAPISchema;