@treatwell/moleculer-essentials 1.0.0

package/dist/index-BV1ZqQrU.mjs

@@ -0,0 +1,351 @@
+import { omit, pick } from 'lodash';
+import { z as z$1 } from 'zod/v4';
+import { ObjectId } from 'bson';
+import { parseISO } from 'date-fns';
+import { z } from '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: 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: 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 = 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 = z.transform((val) => {
+  if (typeof val === "string") {
+    const date = parseISO(val);
+    if (!Number.isNaN(date.getTime())) {
+      return date;
+    }
+  }
+  return val;
+}).pipe(z.date());
+const OBJECT_ID_PATTERN = /^[a-f\d]{24}$/i;
+function isObjectId(val) {
+  return val instanceof ObjectId;
+}
+const zodObjectId = z.transform((val) => {
+  if (typeof val === "string" && OBJECT_ID_PATTERN.test(val)) {
+    return new ObjectId(val);
+  }
+  return val;
+}).pipe(z.custom(isObjectId, { abort: true })).meta({ id: "ObjectId" });
+function zodCoerceArray(element, params) {
+  return z.transform((val) => !Array.isArray(val) && val !== void 0 ? [val] : val).pipe(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 z$1.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
+          }
+        }
+      }
+    }
+  };
+}
+
+export { COERCE_ARRAY_ATTRIBUTE as C, DATE_TYPE as D, EMPTY_OBJECT_SCHEMA as E, FileTooBigSchema as F, GetOpenApiParamsSchema as G, OBJECTID_TYPE as O, SCHEMA_REF_NAME as S, UnauthorizedErrorSchema as U, ValidationErrorSchema as V, FileNotExistSchema as a, ServerErrorSchema as b, addFieldsToSchema as c, optionalFields as d, optionalExceptFields as e, composeSchemas as f, zodDate as g, zodObjectId as h, zodCoerceArray as i, createOpenAPIResponses as j, omitFields as o, pickFields as p, toPartialSchema as t, zodToOpenAPISchema as z };

package/dist/index-DNJWwcZu.mjs

@@ -0,0 +1,8 @@
+function wrapMixin(svc) {
+  return svc;
+}
+function wrapService(svc) {
+  return svc;
+}
+
+export { wrapService as a, wrapMixin as w };