@deliverart/sdk-js-point-of-sale 0.0.1

package/.changeset/config.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://unpkg.com/@changesets/config@3.1.1/schema.json",
+  "changelog": "@changesets/cli/changelog",
+  "commit": false,
+  "fixed": [],
+  "linked": [],
+  "access": "restricted",
+  "baseBranch": "main",
+  "updateInternalDependencies": "patch",
+  "ignore": []
+}

package/.github/workflows/workflow.yml

@@ -0,0 +1,47 @@
+name: Release
+
+on:
+  push:
+    branches:
+      - main
+
+permissions:
+  contents: write
+
+jobs:
+  release:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: pnpm/action-setup@v2
+        with:
+          version: 8
+
+      - uses: actions/setup-node@v4
+        with:
+          node-version: '20'
+          registry-url: 'https://registry.npmjs.org'
+          always-auth: true
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Install deps
+        run: pnpm install
+
+      - name: Build
+        run: pnpm build
+
+      - name: Create version and changelog
+        run: pnpx @changesets/cli version
+
+      - name: Publish to NPM
+        run: pnpx @changesets/cli publish
+        env:
+          NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}
+
+      - name: Push updated versions and changelogs
+        uses: EndBug/add-and-commit@v9
+        with:
+          message: 'chore(release): version bump'
+          add: '.'

package/.prettierrc

@@ -0,0 +1,7 @@
+{
+  "semi": false,
+  "singleQuote": true,
+  "printWidth": 100,
+  "trailingComma": "all",
+  "arrowParens": "avoid"
+}

package/README.md

@@ -0,0 +1,3 @@
+# sdk-js-point-of-sale
+
+Point of sale requests and models for SDK

package/dist/index.cjs

@@ -0,0 +1,304 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  CreatePointOfSale: () => CreatePointOfSale,
+  DeletePointOfSale: () => DeletePointOfSale,
+  GetPointOfSaleDetails: () => GetPointOfSaleDetails,
+  GetPointOfSales: () => GetPointOfSales,
+  UpdatePointOfSale: () => UpdatePointOfSale,
+  createPointOfSaleInputSchema: () => createPointOfSaleInputSchema,
+  createPointOfSaleResponseSchema: () => createPointOfSaleResponseSchema,
+  deletePointOfSaleInputSchema: () => deletePointOfSaleInputSchema,
+  deletePointOfSaleResponseSchema: () => deletePointOfSaleResponseSchema,
+  deliveryTimeSettingSchema: () => deliveryTimeSettingSchema,
+  getCompaniesInputSchema: () => getCompaniesInputSchema,
+  getCompaniesQuerySchema: () => getCompaniesQuerySchema,
+  getCompaniesResponseSchema: () => getCompaniesResponseSchema,
+  getPointOfSaleDetailsInputSchema: () => getPointOfSaleDetailsInputSchema,
+  getPointOfSaleDetailsResponseSchema: () => getPointOfSaleDetailsResponseSchema,
+  pointOfSaleAutoAcceptOrderValues: () => pointOfSaleAutoAcceptOrderValues,
+  pointOfSaleCapabilities: () => pointOfSaleCapabilities,
+  pointOfSaleCapabilitySchema: () => pointOfSaleCapabilitySchema,
+  pointOfSaleDetailsSchema: () => pointOfSaleDetailsSchema,
+  pointOfSaleIntervalValues: () => pointOfSaleIntervalValues,
+  pointOfSaleOpeningStatusSchema: () => pointOfSaleOpeningStatusSchema,
+  pointOfSaleOpeningStatuses: () => pointOfSaleOpeningStatuses,
+  pointOfSaleSchema: () => pointOfSaleSchema,
+  pointOfSaleUserRoleSchema: () => pointOfSaleUserRoleSchema,
+  pointOfSaleUserRoles: () => pointOfSaleUserRoles,
+  timeSettingSchema: () => timeSettingSchema,
+  updatePointOfSaleInputSchema: () => updatePointOfSaleInputSchema,
+  updatePointOfSaleResponseSchema: () => updatePointOfSaleResponseSchema,
+  userPointOfSaleSchema: () => userPointOfSaleSchema,
+  writableCreatePointOfSaleSchema: () => writableCreatePointOfSaleSchema,
+  writablePointOfSaleSchema: () => writablePointOfSaleSchema
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/models.ts
+var import_sdk_js_global_types = require("@deliverart/sdk-js-global-types");
+var import_zod2 = require("zod");
+
+// src/types.ts
+var import_zod = require("zod");
+var pointOfSaleOpeningStatuses = ["OPEN", "CLOSED"];
+var pointOfSaleOpeningStatusSchema = import_zod.z.enum(pointOfSaleOpeningStatuses);
+var pointOfSaleCapabilities = ["DELIVERY_OPTIMIZATION"];
+var pointOfSaleCapabilitySchema = import_zod.z.enum(pointOfSaleCapabilities);
+var pointOfSaleUserRoles = ["ROLE_ADMIN", "ROLE_READER"];
+var pointOfSaleUserRoleSchema = import_zod.z.enum(pointOfSaleUserRoles);
+
+// src/models.ts
+var timeSettingSchema = import_zod2.z.object({
+  dayOfWeek: import_sdk_js_global_types.dayOfWeekSchema,
+  times: import_zod2.z.object({
+    startTime: import_zod2.z.string().regex(/^\d{2}:\d{2}$/),
+    endTime: import_zod2.z.string().regex(/^\d{2}:\d{2}$/)
+  }).array()
+});
+var deliveryTimeSettingSchema = import_zod2.z.object({
+  dayOfWeek: import_sdk_js_global_types.dayOfWeekSchema,
+  times: import_zod2.z.object({
+    startTime: import_zod2.z.string().regex(/^\d{2}:\d{2}$/),
+    endTime: import_zod2.z.string().regex(/^\d{2}:\d{2}$/),
+    availableCouriers: import_zod2.z.number().nonnegative()
+  }).array()
+});
+var pointOfSaleSchema = import_zod2.z.object({
+  id: import_zod2.z.string(),
+  name: import_zod2.z.string(),
+  address: import_sdk_js_global_types.addressSchema,
+  timezone: import_zod2.z.string(),
+  location: import_zod2.z.object({
+    latitude: import_zod2.z.number(),
+    longitude: import_zod2.z.number()
+  }),
+  capabilities: pointOfSaleCapabilitySchema.array(),
+  openingStatus: pointOfSaleOpeningStatusSchema,
+  createdAt: import_sdk_js_global_types.datetimeSchema,
+  updatedAt: import_sdk_js_global_types.datetimeSchema
+});
+var userPointOfSaleSchema = import_zod2.z.object({
+  pointOfSale: pointOfSaleSchema,
+  role: pointOfSaleUserRoleSchema
+});
+var pointOfSaleIntervalValues = [5, 10, 15, 20, 30, 60];
+var pointOfSaleAutoAcceptOrderValues = [0, 5, 10, 15];
+var pointOfSaleDetailsSchema = pointOfSaleSchema.extend({
+  company: import_zod2.z.string().regex(
+    /^\/companies\/[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}$/
+  ),
+  settings: import_zod2.z.object({
+    menuLocales: import_zod2.z.any().array(),
+    deliveryTimesInterval: import_zod2.z.number().positive().refine((value) => pointOfSaleIntervalValues.includes(value)),
+    takeAwayTimesInterval: import_zod2.z.number().positive().refine((value) => pointOfSaleIntervalValues.includes(value)),
+    numberMinutesToPrecessFirstOrder: import_zod2.z.number().positive(),
+    numberMinutesTimeChangeTolerance: import_zod2.z.number().positive(),
+    maxCountableItemsPerBundle: import_zod2.z.number().positive(),
+    maxOrdersPerBundle: import_zod2.z.number().positive(),
+    preventOrderTakingIfTheMaxCountableItemsExceeded: import_zod2.z.boolean(),
+    numberMinutesBeforeAutoAcceptOrder: import_zod2.z.number().nonnegative().refine((value) => pointOfSaleAutoAcceptOrderValues.includes(value))
+  }),
+  openingTimeSettings: timeSettingSchema.array(),
+  deliveryTimeSettings: deliveryTimeSettingSchema.array(),
+  takeAwayTimeSettings: timeSettingSchema.array(),
+  numberOfCouriers: import_zod2.z.number().nonnegative()
+});
+var writablePointOfSaleSchema = pointOfSaleDetailsSchema.pick({
+  name: true,
+  address: true,
+  timezone: true,
+  settings: true,
+  openingTimeSettings: true,
+  deliveryTimeSettings: true,
+  takeAwayTimeSettings: true,
+  capabilities: true,
+  openingStatus: true
+});
+var writableCreatePointOfSaleSchema = import_zod2.z.object({
+  ...writablePointOfSaleSchema.shape,
+  ...pointOfSaleDetailsSchema.pick({
+    company: true
+  }).shape
+});
+
+// src/requests/CreatePointOfSale.ts
+var import_sdk_js_core = require("@deliverart/sdk-js-core");
+var createPointOfSaleInputSchema = writableCreatePointOfSaleSchema.required();
+var createPointOfSaleResponseSchema = pointOfSaleDetailsSchema;
+var CreatePointOfSale = class extends import_sdk_js_core.AbstractApiRequest {
+  method = "POST";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = createPointOfSaleInputSchema;
+  outputSchema = createPointOfSaleResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  constructor(input) {
+    super(input);
+  }
+  getPath() {
+    return "/point_of_sales";
+  }
+};
+
+// src/requests/DeletePointOfSale.ts
+var import_sdk_js_core2 = require("@deliverart/sdk-js-core");
+var import_zod3 = require("zod");
+var deletePointOfSaleInputSchema = import_zod3.z.undefined();
+var deletePointOfSaleResponseSchema = import_zod3.z.undefined();
+var DeletePointOfSale = class extends import_sdk_js_core2.AbstractApiRequest {
+  method = "DELETE";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = deletePointOfSaleInputSchema;
+  outputSchema = deletePointOfSaleResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  pointOfSaleId;
+  constructor(pointOfSaleId) {
+    super();
+    this.pointOfSaleId = pointOfSaleId;
+  }
+  getPath() {
+    return `/point_of_sales/${this.pointOfSaleId}`;
+  }
+};
+
+// src/requests/GetPointOfSaleDetails.ts
+var import_sdk_js_core3 = require("@deliverart/sdk-js-core");
+var import_zod4 = require("zod");
+var getPointOfSaleDetailsInputSchema = import_zod4.z.undefined();
+var getPointOfSaleDetailsResponseSchema = pointOfSaleDetailsSchema;
+var GetPointOfSaleDetails = class extends import_sdk_js_core3.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getPointOfSaleDetailsInputSchema;
+  outputSchema = getPointOfSaleDetailsResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  pointOfSaleId;
+  constructor(pointOfSaleId) {
+    super();
+    this.pointOfSaleId = pointOfSaleId;
+  }
+  getPath() {
+    return `/point_of_sales/${this.pointOfSaleId}`;
+  }
+};
+
+// src/requests/GetPointOfSales.ts
+var import_sdk_js_core4 = require("@deliverart/sdk-js-core");
+var import_sdk_js_global_types2 = require("@deliverart/sdk-js-global-types");
+var import_zod5 = require("zod");
+var getCompaniesQuerySchema = import_zod5.z.object({
+  name: import_zod5.z.string().optional(),
+  openingStatus: pointOfSaleOpeningStatusSchema.optional(),
+  "integrationActivationRequests.connectionId": import_zod5.z.string().optional(),
+  "address.city": import_zod5.z.string().optional(),
+  "address.postalCode": import_zod5.z.string().optional(),
+  "order[name]": import_sdk_js_global_types2.sortDirSchema.optional(),
+  "order[createdAt]": import_sdk_js_global_types2.sortDirSchema.optional(),
+  "order[updatedAt]": import_sdk_js_global_types2.sortDirSchema.optional(),
+  page: import_zod5.z.coerce.number().optional()
+});
+var getCompaniesResponseSchema = (0, import_sdk_js_global_types2.createPaginatedSchema)(pointOfSaleSchema);
+var getCompaniesInputSchema = import_zod5.z.undefined();
+var GetPointOfSales = class extends import_sdk_js_core4.AbstractApiRequest {
+  method = "GET";
+  contentType = "application/json";
+  accept = "application/json";
+  inputSchema = getCompaniesInputSchema;
+  outputSchema = getCompaniesResponseSchema;
+  querySchema = getCompaniesQuerySchema;
+  headersSchema = void 0;
+  constructor(options) {
+    super(void 0, options);
+  }
+  getPath() {
+    return "/point_of_sales";
+  }
+  parseResponse(data, rawResponse) {
+    const pointOfSales = import_zod5.z.array(pointOfSaleSchema).parse(data);
+    return this.validateOutput({
+      data: pointOfSales,
+      pagination: (0, import_sdk_js_global_types2.responseToPagination)(rawResponse)
+    });
+  }
+};
+
+// src/requests/UpdatePointOfSale.ts
+var import_sdk_js_core5 = require("@deliverart/sdk-js-core");
+var updatePointOfSaleInputSchema = writablePointOfSaleSchema.partial();
+var updatePointOfSaleResponseSchema = pointOfSaleDetailsSchema;
+var UpdatePointOfSale = class extends import_sdk_js_core5.AbstractApiRequest {
+  method = "PATCH";
+  contentType = "application/merge-patch+json";
+  accept = "application/json";
+  inputSchema = updatePointOfSaleInputSchema;
+  outputSchema = updatePointOfSaleResponseSchema;
+  querySchema = void 0;
+  headersSchema = void 0;
+  pointOfSaleId;
+  constructor(pointOfSaleId, input) {
+    super(input);
+    this.pointOfSaleId = pointOfSaleId;
+  }
+  getPath() {
+    return `/point_of_sales/${this.pointOfSaleId}`;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CreatePointOfSale,
+  DeletePointOfSale,
+  GetPointOfSaleDetails,
+  GetPointOfSales,
+  UpdatePointOfSale,
+  createPointOfSaleInputSchema,
+  createPointOfSaleResponseSchema,
+  deletePointOfSaleInputSchema,
+  deletePointOfSaleResponseSchema,
+  deliveryTimeSettingSchema,
+  getCompaniesInputSchema,
+  getCompaniesQuerySchema,
+  getCompaniesResponseSchema,
+  getPointOfSaleDetailsInputSchema,
+  getPointOfSaleDetailsResponseSchema,
+  pointOfSaleAutoAcceptOrderValues,
+  pointOfSaleCapabilities,
+  pointOfSaleCapabilitySchema,
+  pointOfSaleDetailsSchema,
+  pointOfSaleIntervalValues,
+  pointOfSaleOpeningStatusSchema,
+  pointOfSaleOpeningStatuses,
+  pointOfSaleSchema,
+  pointOfSaleUserRoleSchema,
+  pointOfSaleUserRoles,
+  timeSettingSchema,
+  updatePointOfSaleInputSchema,
+  updatePointOfSaleResponseSchema,
+  userPointOfSaleSchema,
+  writableCreatePointOfSaleSchema,
+  writablePointOfSaleSchema
+});