@deliverart/sdk-js-core 0.0.0-dev-20260721002647

package/dist/index.cjs

@@ -0,0 +1,646 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  AbstractApiRequest: () => AbstractApiRequest,
+  InputValidationError: () => InputValidationError,
+  OutputValidationError: () => OutputValidationError,
+  createApiClient: () => createApiClient,
+  deserializeFromClient: () => deserializeFromClient,
+  serializeForClient: () => serializeForClient,
+  serializedIriObjectSchema: () => serializedIriObjectSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../global-types/dist/index.js
+var import_zod = require("zod");
+var import_zod2 = require("zod");
+var import_zod3 = require("zod");
+var import_zod4 = require("zod");
+var daysOfWeek = [
+  "monday",
+  "tuesday",
+  "wednesday",
+  "thursday",
+  "friday",
+  "saturday",
+  "sunday"
+];
+var sortDirections = ["asc", "desc"];
+var queryParamsDateCompare = [
+  "before",
+  "strictly_before",
+  "after",
+  "strictly_after"
+];
+var queryParamsNumberCompare = ["gt", "gte", "lt", "lte"];
+var arrayContainsMatchOptions = ["all", "any"];
+var emailTemplateKeys = [
+  "delivery_started",
+  "delivery_taken_over",
+  "order_created",
+  "order_delivered",
+  "order_in_preparation",
+  "order_preparation_done",
+  "subscription_expiring",
+  "subscription_low_credits",
+  "subscription_pending_renewal",
+  "subscription_payment_pending_verification"
+];
+var emailTemplateKeySchema = import_zod.z.enum(emailTemplateKeys);
+var apiTokenTypes = ["full_access", "point_of_sale"];
+var apiTokenTypeSchema = import_zod.z.enum(apiTokenTypes);
+var apiTokenModes = ["READ_ONLY", "READ_AND_WRITE"];
+var apiTokenModeSchema = import_zod.z.enum(apiTokenModes);
+var deliveryFeeTypes = ["amount", "distance", "postal_code"];
+var deliveryFeeTypeSchema = import_zod.z.enum(deliveryFeeTypes);
+var menuChannels = [
+  "application",
+  "ecommerce",
+  "deliveroo",
+  "justeat",
+  "glovo",
+  "tilby",
+  "cassa_in_cloud",
+  "elephant"
+];
+var menuChannelSchema = import_zod.z.enum(menuChannels);
+var orderPartners = [
+  "cassa_in_cloud",
+  "deliveroo",
+  "justeat",
+  "glovo",
+  "tilby",
+  "elephant"
+];
+var orderPartnerSchema = import_zod.z.enum(orderPartners);
+var menuItemAllergens = [
+  "peanuts-and-derivatives",
+  "crustaceans",
+  "nuts",
+  "gluten",
+  "milk-and-derivatives",
+  "lupins",
+  "molluscs",
+  "mustard",
+  "fish",
+  "celery",
+  "sesame",
+  "sulfur-dioxide",
+  "soy",
+  "eggs-and-derivatives",
+  "mushrooms"
+];
+var menuItemAllergenSchema = import_zod.z.enum(menuItemAllergens);
+var menuItemDiets = ["vegan", "vegetarian", "gluten-free", "dairy-free"];
+var menuItemDietSchema = import_zod.z.enum(menuItemDiets);
+var menuItemPriceOverrideTypes = ["ITEM", "MODIFIER"];
+var menuItemPriceOverrideTypeSchema = import_zod.z.enum(menuItemPriceOverrideTypes);
+var menuItemTypes = ["ITEM", "CHOICE", "BUNDLE"];
+var menuItemTypeSchema = import_zod.z.enum(menuItemTypes);
+var menuItemModifierTargetItemTypes = ["ITEM", "BUNDLE"];
+var menuItemModifierTargetItemTypeSchema = import_zod.z.enum(menuItemModifierTargetItemTypes);
+var menuItemModifierScopes = ["global", "category", "item"];
+var menuItemModifierScopeSchema = import_zod.z.enum(menuItemModifierScopes);
+var orderTypes = ["delivery", "collection", "kitchen"];
+var orderTypeSchema = import_zod.z.union([import_zod.z.enum(orderTypes), import_zod.z.literal("take_away")]).transform((value) => value === "take_away" ? "collection" : value);
+var orderSources = ["application", "ecommerce", "partner"];
+var orderSourceSchema = import_zod.z.enum(orderSources);
+var orderStatuses = ["pending", "confirmed", "rejected"];
+var orderStatusSchema = import_zod.z.enum(orderStatuses);
+var orderPreparationStatuses = ["to_prepare", "in_preparation", "done"];
+var orderPreparationStatusSchema = import_zod.z.enum(orderPreparationStatuses);
+var orderMenuItemActions = ["add", "remove"];
+var orderMenuItemActionSchema = import_zod.z.enum(orderMenuItemActions);
+var orderPlanningModes = ["PLANNED", "FORCED"];
+var orderPlanningModeSchema = import_zod.z.enum(orderPlanningModes);
+var bundleStatuses = ["pending", "busy", "broken", "released"];
+var bundleStatusSchema = import_zod.z.enum(bundleStatuses);
+var bundleTypes = ["REGULAR", "FORCED"];
+var bundleTypeSchema = import_zod.z.enum(bundleTypes);
+var bundleBundleBrokenReasons = ["delivery_removed"];
+var bundleBundleBrokenReasonSchema = import_zod.z.enum(bundleBundleBrokenReasons);
+var slotInvalidReasons = [
+  "store_closed",
+  "no_capacity",
+  "outside_lead_time",
+  "journey_outside_window"
+];
+var slotInvalidReasonSchema = import_zod.z.enum(slotInvalidReasons);
+var rescheduleOptionStatuses = [
+  "keep_current_bundle",
+  "create_new_bundle",
+  "move_to_reference_bundle",
+  "unavailable"
+];
+var rescheduleOptionStatusSchema = import_zod.z.enum(rescheduleOptionStatuses);
+var deliveryRunStates = [
+  "not_started",
+  "awaiting_stop_selection",
+  "delivering_stop",
+  "ready_to_finish",
+  "finished"
+];
+var deliveryRunStateSchema = import_zod.z.enum(deliveryRunStates);
+var paymentMethods = ["stripe", "bank_transfer", "cash", "credit_card"];
+var paymentMethodSchema = import_zod.z.enum(paymentMethods);
+var paymentStatuses = [
+  "pending",
+  "pending_verification",
+  "paid",
+  "canceled",
+  "refunded",
+  "failed"
+];
+var paymentStatusSchema = import_zod.z.enum(paymentStatuses);
+var subscriptionStatuses = [
+  "created",
+  "active",
+  "pending_renewal",
+  "expired",
+  "suspended",
+  "cancelled"
+];
+var subscriptionStatusSchema = import_zod.z.enum(subscriptionStatuses);
+var subscriptionTypes = ["infinite", "time_based", "consumption"];
+var subscriptionTypeSchema = import_zod.z.enum(subscriptionTypes);
+var renewalStatuses = [
+  "pending",
+  "pending_verification",
+  "completed",
+  "cancelled",
+  "failed"
+];
+var renewalStatusSchema = import_zod.z.enum(renewalStatuses);
+var creditTransactionTypes = [
+  "consumption",
+  "renewal",
+  "gift",
+  "bonus",
+  "refund",
+  "manual_adjustment"
+];
+var creditTransactionTypeSchema = import_zod.z.enum(creditTransactionTypes);
+var printerProtocols = ["epson_epos", "esc_pos"];
+var printerProtocolSchema = import_zod.z.enum(printerProtocols);
+var printerDrivers = ["epson_sdk", "epos_print_xml"];
+var printerDriverSchema = import_zod.z.enum(printerDrivers);
+var printerReceiptProfiles = [
+  "80mm_42col",
+  "80mm_48col",
+  "58mm_32col",
+  "58mm_35col"
+];
+var printerReceiptProfileSchema = import_zod.z.enum(printerReceiptProfiles);
+var webhookEvents = ["create", "update", "delete"];
+var webhookEventSchema = import_zod.z.enum(webhookEvents);
+var webhookLogStatuses = ["pending", "success", "failed", "timeout"];
+var webhookLogStatusSchema = import_zod.z.enum(webhookLogStatuses);
+var webhookEntities = [
+  "App\\Entity\\Bundle",
+  "App\\Entity\\Customer",
+  "App\\Entity\\CustomerAddress",
+  "App\\Entity\\CustomerBusinessProfile",
+  "App\\Entity\\Delivery",
+  "App\\Entity\\DeliveryPosition",
+  "App\\Entity\\Integration",
+  "App\\Entity\\IntegrationActivationRequest",
+  "App\\Entity\\Order",
+  "App\\Entity\\PointOfSale"
+];
+var webhookEntitySchema = import_zod.z.enum(webhookEntities);
+var uuidPattern = /^[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}$/i;
+var isUuid = (s) => uuidPattern.test(s);
+var uuidLikeSchema = import_zod2.z.string().regex(uuidPattern, { message: "Invalid UUID format" });
+var IriObject = class {
+  constructor(iri, pattern) {
+    this.iri = iri;
+    this.params = this.extractParams(iri, pattern);
+    this.__pattern = pattern;
+  }
+  extractParams(iri, pattern) {
+    const iriParts = iri.split("/").filter(Boolean);
+    const patternParts = pattern.split("/").filter(Boolean);
+    const result = {};
+    for (let i = 0; i < patternParts.length; i++) {
+      const part = patternParts[i];
+      if (part.startsWith(":")) {
+        const key = part.slice(1);
+        const value = iriParts[i];
+        if (!isUuid(value)) {
+          throw new Error(`Invalid UUID for parameter "${key}": "${value}"`);
+        }
+        result[key] = value;
+      }
+    }
+    return result;
+  }
+  toString() {
+    return this.iri;
+  }
+  toJSON() {
+    return this.iri;
+  }
+};
+var addressSchema = import_zod3.z.object({
+  line1: import_zod3.z.string().nullable().optional(),
+  line2: import_zod3.z.string().nullable().optional(),
+  city: import_zod3.z.string().nullable().optional(),
+  region: import_zod3.z.string().nullable().optional(),
+  postalCode: import_zod3.z.string().nullable().optional(),
+  country: import_zod3.z.string().nullable().optional()
+});
+var billingDataITSchema = import_zod3.z.object({
+  sdi: import_zod3.z.string().trim().optional().nullable(),
+  pec: import_zod3.z.email({ message: "Invalid email format" }).optional().nullable()
+}).check((ctx) => {
+  const { sdi, pec } = ctx.value;
+  const hasSdi = sdi?.trim();
+  const hasPec = pec?.trim();
+  if (!hasSdi && !hasPec) {
+    ctx.issues.push({
+      code: "custom",
+      message: "At least one of SDI or PEC must be provided",
+      path: ["sdi"],
+      input: sdi
+    });
+    ctx.issues.push({
+      code: "custom",
+      message: "At least one of SDI or PEC must be provided",
+      path: ["pec"],
+      input: pec
+    });
+  }
+});
+var booleanSchema = import_zod3.z.preprocess((val) => {
+  if (typeof val === "boolean") {
+    return val;
+  }
+  if (typeof val === "number") {
+    return val === 1;
+  }
+  if (typeof val === "string") {
+    if (val === "true" || val === "1") return true;
+    if (val === "false" || val === "0") return false;
+  }
+  return val;
+}, import_zod3.z.boolean());
+var datetimeSchema = import_zod3.z.string().refine(
+  (value) => {
+    return !isNaN(Date.parse(value));
+  },
+  {
+    message: "Invalid datetime format"
+  }
+);
+var dayOfWeekSchema = import_zod3.z.enum(daysOfWeek);
+var locationSchema = import_zod3.z.object({
+  latitude: import_zod3.z.number(),
+  longitude: import_zod3.z.number()
+});
+var paginationSchema = import_zod3.z.object({
+  from: import_zod3.z.coerce.number(),
+  to: import_zod3.z.coerce.number(),
+  itemsPerPage: import_zod3.z.coerce.number(),
+  totalItems: import_zod3.z.coerce.number(),
+  currentPage: import_zod3.z.coerce.number(),
+  lastPage: import_zod3.z.coerce.number()
+});
+var sortDirSchema = import_zod3.z.enum(sortDirections);
+var queryParamDateCompareSchema = import_zod3.z.enum(queryParamsDateCompare);
+var queryParamNumberCompareSchema = import_zod3.z.enum(queryParamsNumberCompare);
+var timestampsFilterSchema = import_zod3.z.object({
+  "createdAt[before]": import_zod3.z.string().optional(),
+  "createdAt[strictly_before]": import_zod3.z.string().optional(),
+  "createdAt[after]": import_zod3.z.string().optional(),
+  "createdAt[strictly_after]": import_zod3.z.string().optional(),
+  "updatedAt[before]": import_zod3.z.string().optional(),
+  "updatedAt[strictly_before]": import_zod3.z.string().optional(),
+  "updatedAt[after]": import_zod3.z.string().optional(),
+  "updatedAt[strictly_after]": import_zod3.z.string().optional()
+});
+var arrayContainsMatchSchema = import_zod3.z.enum(arrayContainsMatchOptions);
+var emptyResponseSchema = import_zod3.z.union([import_zod3.z.void(), import_zod3.z.undefined(), import_zod3.z.null()]);
+var responseToPagination = (response) => {
+  const getHeader = (name) => {
+    const value = response.headers.get(name);
+    return value !== null ? parseInt(value, 10) : NaN;
+  };
+  return {
+    from: getHeader("x-pagination-from"),
+    to: getHeader("x-pagination-to"),
+    itemsPerPage: getHeader("x-pagination-items-per-page"),
+    totalItems: getHeader("x-pagination-total-items"),
+    currentPage: getHeader("x-pagination-current-page"),
+    lastPage: getHeader("x-pagination-last-page")
+  };
+};
+
+// src/ApiClient.ts
+var import_qs = __toESM(require("qs"), 1);
+var import_zod5 = require("zod");
+
+// src/errors.ts
+var InputValidationError = class extends Error {
+  // eslint-disable-next-line no-unused-vars
+  constructor(issues) {
+    super("Invalid input");
+    this.issues = issues;
+    this.name = "InputValidationError";
+  }
+};
+var OutputValidationError = class extends Error {
+  // eslint-disable-next-line no-unused-vars
+  constructor(issues) {
+    super("Invalid response");
+    this.issues = issues;
+    this.name = "OutputValidationError";
+  }
+};
+
+// src/ApiClient.ts
+function serializeQueryValue(value) {
+  if (Array.isArray(value)) {
+    return value.map(serializeQueryValue);
+  }
+  if (value && typeof value === "object") {
+    const v = value;
+    if (typeof v.iri === "string") {
+      return v.iri;
+    }
+    const maybeToString = value.toString;
+    if (typeof maybeToString === "function") {
+      const str = maybeToString.call(value);
+      if (!str.startsWith("[object")) {
+        return str;
+      }
+    }
+    const out = {};
+    for (const [k, v2] of Object.entries(v)) {
+      out[k] = serializeQueryValue(v2);
+    }
+    return out;
+  }
+  return value;
+}
+var AbstractApiRequest = class {
+  constructor(input2, options) {
+    this.input = input2;
+    this.options = options;
+  }
+  /**
+   * Override this in list requests to provide pagination metadata from the raw HTTP response.
+   * Default implementation uses `responseToPagination`.
+   * Return `undefined` if pagination cannot be resolved.
+   */
+  getPagination(rawResponse) {
+    return responseToPagination(rawResponse);
+  }
+  validateInput() {
+    const result = this.inputSchema.safeParse(this.input);
+    if (!result.success) throw new InputValidationError(result.error.issues);
+    return result.data;
+  }
+  validateQuery() {
+    if (!this.querySchema || !this.options?.query) return void 0;
+    const result = this.querySchema.safeParse(this.options.query);
+    if (!result.success) throw new InputValidationError(result.error.issues);
+    return result.data;
+  }
+  validateHeaders() {
+    if (!this.headersSchema || !this.options?.headers) return void 0;
+    const result = this.headersSchema.safeParse(this.options.headers);
+    if (!result.success) throw new InputValidationError(result.error.issues);
+    return result.data;
+  }
+  validateOutput(data, useArraySchema) {
+    if (useArraySchema && this.listItemSchema) {
+      const arraySchema = import_zod5.z.array(this.listItemSchema);
+      const result2 = arraySchema.safeParse(data);
+      if (!result2.success) throw new OutputValidationError(result2.error.issues);
+      return result2.data;
+    }
+    const result = this.outputSchema.safeParse(data);
+    if (!result.success) throw new OutputValidationError(result.error.issues);
+    return result.data;
+  }
+  parseResponse(data, rawResponse, paginationOption) {
+    if (this.listItemSchema) {
+      const paginationToggle = paginationOption ?? this.paginationDefaultEnabled ?? true;
+      if (paginationOption === false) {
+        return this.validateOutput(data, true);
+      }
+      const arraySchema = import_zod5.z.array(this.listItemSchema);
+      const arrayParse = arraySchema.safeParse(data);
+      if (arrayParse.success) {
+        if (paginationToggle) {
+          const pagination = rawResponse ? this.getPagination(rawResponse) : void 0;
+          if (pagination !== void 0) {
+            return this.validateOutput({ data: arrayParse.data, pagination });
+          }
+        }
+        return this.validateOutput(arrayParse.data, true);
+      }
+      if (Array.isArray(data)) {
+        throw new OutputValidationError(arrayParse.error.issues);
+      }
+    }
+    return this.validateOutput(data);
+  }
+};
+function isFormDataInstance(input2) {
+  return typeof FormData === "function" && typeof input2 === "object" && input2 !== null && input2 instanceof FormData;
+}
+function createApiClient(config) {
+  const requestMiddlewares = [];
+  const responseMiddlewares = [];
+  const base = {
+    fetch,
+    addRequestMiddleware(mw) {
+      requestMiddlewares.push(mw);
+    },
+    addResponseMiddleware(middleware) {
+      responseMiddlewares.push(middleware);
+    },
+    async call(request, options) {
+      const input2 = request.validateInput();
+      const query = request.validateQuery();
+      const headers = request.validateHeaders();
+      const url = new URL(request.getPath(), config.baseUrl);
+      const queryParams = { ...query || {} };
+      if (options?.pagination === false) {
+        queryParams.pagination = false;
+      }
+      if (options?.itemsPerPage !== void 0) {
+        queryParams.itemsPerPage = options.itemsPerPage;
+      }
+      if (Object.keys(queryParams).length > 0) {
+        const queryString = import_qs.default.stringify(serializeQueryValue(queryParams), {
+          arrayFormat: "brackets",
+          skipNulls: true
+        });
+        if (queryString) {
+          url.search = queryString;
+        }
+      }
+      const isGet = request.method === "GET";
+      const isFormData = request.contentType === "multipart/form-data";
+      const fetchHeaders = {
+        Accept: request.accept,
+        ...headers ?? {}
+      };
+      let body;
+      if (!isGet) {
+        if (isFormData && isFormDataInstance(input2)) {
+          body = input2;
+        } else {
+          fetchHeaders["Content-Type"] = request.contentType;
+          body = JSON.stringify(input2);
+        }
+      }
+      let ctx = {
+        url,
+        init: {
+          method: request.method,
+          headers: fetchHeaders,
+          body
+        }
+      };
+      for (const middleware of requestMiddlewares) {
+        ctx = await middleware(ctx);
+      }
+      let response = await fetch(ctx.url.toString(), ctx.init);
+      let contentType = response.headers.get("Content-Type") ?? "";
+      let parsedBody;
+      if (response.status === 204) {
+        parsedBody = null;
+      } else {
+        try {
+          if (contentType.includes("application/")) {
+            if (contentType.includes("json")) {
+              parsedBody = await response.json();
+            } else {
+              parsedBody = await response.text();
+            }
+          } else if (contentType.includes("text/")) {
+            parsedBody = await response.text();
+          } else {
+            parsedBody = await response.arrayBuffer();
+          }
+        } catch (err) {
+          parsedBody = void 0;
+        }
+      }
+      let parsedResponse = {
+        response,
+        body: parsedBody
+      };
+      for (const middleware of responseMiddlewares) {
+        parsedResponse = await middleware(parsedResponse, ctx);
+      }
+      if (!parsedResponse.response.ok) {
+        throw new Error(`HTTP ${parsedResponse.response.status}`);
+      }
+      return request.parseResponse(
+        parsedResponse.body,
+        parsedResponse.response,
+        options?.pagination
+      );
+    },
+    addPlugin(plugin) {
+      const extension = plugin.setup(this);
+      return { ...this, ...extension };
+    }
+  };
+  return base;
+}
+
+// src/serialization.ts
+var import_zod6 = require("zod");
+var serializedIriObjectSchema = import_zod6.z.object({
+  iri: import_zod6.z.string().min(1),
+  params: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()),
+  __pattern: import_zod6.z.string().min(1)
+}).strict();
+function isSerializedIriObject(input2) {
+  return typeof input2 === "object" && input2 !== null && "iri" in input2 && "params" in input2 && "__pattern" in input2 && typeof input2.iri === "string" && typeof input2.__pattern === "string" && typeof input2.params === "object";
+}
+function deserializeIri(s) {
+  return new IriObject(s.iri, s.__pattern);
+}
+function serializeForClient(input2) {
+  if (input2 instanceof IriObject) {
+    return {
+      iri: input2.iri,
+      params: input2.params,
+      __pattern: input2.__pattern
+      // qui P è literal
+    };
+  }
+  if (Array.isArray(input2)) {
+    return input2.map((item) => serializeForClient(item));
+  }
+  if (input2 !== null && typeof input2 === "object") {
+    const result = {};
+    for (const key in input2) {
+      const value = input2[key];
+      result[key] = serializeForClient(value);
+    }
+    return result;
+  }
+  return input2;
+}
+function deserializeFromClient(input2) {
+  if (isSerializedIriObject(input2)) {
+    return deserializeIri(input2);
+  }
+  if (Array.isArray(input2)) {
+    return input2.map((item) => deserializeFromClient(item));
+  }
+  if (input2 !== null && typeof input2 === "object") {
+    const result = {};
+    for (const key in input2) {
+      result[key] = deserializeFromClient(input2[key]);
+    }
+    return result;
+  }
+  return input2;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AbstractApiRequest,
+  InputValidationError,
+  OutputValidationError,
+  createApiClient,
+  deserializeFromClient,
+  serializeForClient,
+  serializedIriObjectSchema
+});