@floristcloud/api-lib 1.2.25 → 1.2.27

package/build/commands/integration/moysklad/get-moysklad-status.query.js

@@ -16,6 +16,14 @@ const GetMoyskladStatusResponseSchema = zod_1.z.object({
         nameProcessingConvention: zod_1.z.nativeEnum(consignment_import_name_convention_enum_1.ConsignmentImportNameConventionEnum).nullable(),
         isRemoveSizeFromName: zod_1.z.boolean(),
         isCutCategoryFromName: zod_1.z.boolean(),
+        lastStockSyncedAt: zod_1.z.string().datetime().nullable(),
+        stockSyncStatus: zod_1.z.enum(['PENDING', 'RUNNING', 'DEAD', 'IDLE']),
+        stockSyncDeadInfo: zod_1.z
+            .object({
+            errorCode: zod_1.z.string(),
+            errorMessage: zod_1.z.string(),
+        })
+            .nullable(),
     }),
 });
 var GetMoyskladStatusContractQuery;

package/build/commands/integration/moysklad/get-order-sync-status.query.js

@@ -0,0 +1,38 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOrderSyncStatusContractQuery = void 0;
+const zod_1 = require("zod");
+const outbound_sync_intent_enum_1 = require("../../../enum/outbound-sync-intent.enum");
+const PendingJobSchema = zod_1.z.object({
+    intent: zod_1.z.nativeEnum(outbound_sync_intent_enum_1.OutboundSyncIntentEnum),
+    attempts: zod_1.z.number().int().nonnegative(),
+    errorCode: zod_1.z.string().nullable(),
+    errorMessage: zod_1.z.string().nullable(),
+    nextAttemptAt: zod_1.z.string().datetime(),
+});
+const DeadJobSchema = zod_1.z.object({
+    intent: zod_1.z.nativeEnum(outbound_sync_intent_enum_1.OutboundSyncIntentEnum),
+    errorCode: zod_1.z.string(),
+    errorMessage: zod_1.z.string(),
+});
+const OrderSyncStatusSchema = zod_1.z.object({
+    orderUUID: zod_1.z.string().uuid(),
+    isLinked: zod_1.z.boolean(),
+    externalHref: zod_1.z.string().nullable(),
+    isClientLinked: zod_1.z.boolean(),
+    hasUnlinkedProducts: zod_1.z.boolean(),
+    missingProductUUIDs: zod_1.z.array(zod_1.z.string().uuid()),
+    lastSyncedAt: zod_1.z.string().datetime().nullable(),
+    pendingJob: PendingJobSchema.nullable(),
+    isDead: zod_1.z.boolean(),
+    deadJob: DeadJobSchema.nullable(),
+});
+const GetOrderSyncStatusResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: OrderSyncStatusSchema,
+});
+var GetOrderSyncStatusContractQuery;
+(function (GetOrderSyncStatusContractQuery) {
+    GetOrderSyncStatusContractQuery.ResponseSchema = GetOrderSyncStatusResponseSchema;
+    GetOrderSyncStatusContractQuery.StatusSchema = OrderSyncStatusSchema;
+})(GetOrderSyncStatusContractQuery || (exports.GetOrderSyncStatusContractQuery = GetOrderSyncStatusContractQuery = {}));

package/build/commands/integration/moysklad/get-orders-batch-sync-status.query.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetOrdersBatchSyncStatusContractQuery = void 0;
+const zod_1 = require("zod");
+const GetOrdersBatchSyncStatusRequestSchema = zod_1.z.object({
+    orderUUIDs: zod_1.z.array(zod_1.z.string().uuid()).min(1).max(200),
+});
+const OrderSyncStatusSlimSchema = zod_1.z.object({
+    orderUUID: zod_1.z.string().uuid(),
+    isLinked: zod_1.z.boolean(),
+    hasIssues: zod_1.z.boolean(),
+});
+const GetOrdersBatchSyncStatusResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        statuses: zod_1.z.array(OrderSyncStatusSlimSchema),
+    }),
+});
+var GetOrdersBatchSyncStatusContractQuery;
+(function (GetOrdersBatchSyncStatusContractQuery) {
+    GetOrdersBatchSyncStatusContractQuery.RequestSchema = GetOrdersBatchSyncStatusRequestSchema;
+    GetOrdersBatchSyncStatusContractQuery.ResponseSchema = GetOrdersBatchSyncStatusResponseSchema;
+    GetOrdersBatchSyncStatusContractQuery.SlimStatusSchema = OrderSyncStatusSlimSchema;
+})(GetOrdersBatchSyncStatusContractQuery || (exports.GetOrdersBatchSyncStatusContractQuery = GetOrdersBatchSyncStatusContractQuery = {}));

package/build/commands/integration/moysklad/index.js

@@ -24,3 +24,6 @@ __exportStar(require("./scan-moysklad-import.query"), exports);
 __exportStar(require("./execute-moysklad-import.command"), exports);
 __exportStar(require("./scan-moysklad-clients-import.query"), exports);
 __exportStar(require("./execute-moysklad-clients-import.command"), exports);
+__exportStar(require("./get-order-sync-status.query"), exports);
+__exportStar(require("./get-orders-batch-sync-status.query"), exports);
+__exportStar(require("./sync-moysklad-stock.command"), exports);

package/build/commands/integration/moysklad/sync-moysklad-stock.command.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SyncMoyskladStockContractCommand = void 0;
+const zod_1 = require("zod");
+const SyncMoyskladStockResponseSchema = zod_1.z.object({
+    message: zod_1.z.string().optional(),
+    data: zod_1.z.object({
+        jobUUID: zod_1.z.string().uuid(),
+        status: zod_1.z.enum(['PENDING', 'RUNNING']),
+        wasAlreadyQueued: zod_1.z.boolean(),
+    }),
+});
+var SyncMoyskladStockContractCommand;
+(function (SyncMoyskladStockContractCommand) {
+    SyncMoyskladStockContractCommand.ResponseSchema = SyncMoyskladStockResponseSchema;
+})(SyncMoyskladStockContractCommand || (exports.SyncMoyskladStockContractCommand = SyncMoyskladStockContractCommand = {}));

package/build/constant/error.js

@@ -986,7 +986,11 @@ exports.ERRORS = {
     MOYSKLAD_NOT_CONNECTED: { code: 'MS003', message: 'MoySklad integration is not connected for this company', httpCode: 404 },
     MOYSKLAD_API_ERROR: { code: 'MS004', message: 'MoySklad API request failed', httpCode: 502 },
     MOYSKLAD_DISCONNECT_FAILED: { code: 'MS005', message: 'Failed to disconnect MoySklad integration', httpCode: 500 },
-    MOYSKLAD_SETTINGS_INVALID: { code: 'MS006', message: 'Provided organization or store does not belong to the connected MoySklad account', httpCode: 400 },
+    MOYSKLAD_SETTINGS_INVALID: {
+        code: 'MS006',
+        message: 'Provided organization or store does not belong to the connected MoySklad account',
+        httpCode: 400,
+    },
     INTEGRATION_ENC_KEY_NOT_SET: { code: 'MS007', message: 'Integration encryption key is not configured on the server', httpCode: 500 },
     MOYSKLAD_IMPORT_IN_PROGRESS: { code: 'MS008', message: 'MoySklad import is already in progress for this company', httpCode: 409 },
     MOYSKLAD_CLIENTS_IMPORT_IN_PROGRESS: {
@@ -1004,11 +1008,6 @@ exports.ERRORS = {
         message: 'Order client has no MoySklad link; import clients first',
         httpCode: 400,
     },
-    MOYSKLAD_ORDER_PRODUCT_NOT_LINKED: {
-        code: 'MS012',
-        message: 'One or more order products have no MoySklad link',
-        httpCode: 400,
-    },
     MOYSKLAD_INTEGRATION_INCOMPLETE: {
         code: 'MS013',
         message: 'MoySklad integration is missing default organization or store',
@@ -1034,4 +1033,19 @@ exports.ERRORS = {
         message: 'Outbound sync entity type is not supported by this provider',
         httpCode: 400,
     },
+    MOYSKLAD_STOCK_SYNC_CAP_EXCEEDED: {
+        code: 'MS015',
+        message: 'MoySklad stock-sync concurrency cap exceeded; will retry shortly',
+        httpCode: 429,
+    },
+    MOYSKLAD_STOCK_SYNC_LOCK_BUSY: {
+        code: 'MS016',
+        message: 'MoySklad sync lock is held by another job for this company; will retry shortly',
+        httpCode: 409,
+    },
+    MOYSKLAD_INTEGRATION_DISABLED: {
+        code: 'MS017',
+        message: 'MoySklad integration is disabled for this company',
+        httpCode: 409,
+    },
 };

package/build/enum/color-code.enum.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isColorCode = exports.COLOR_CODE_LIST = exports.ColorCodeEnum = void 0;
+var ColorCodeEnum;
+(function (ColorCodeEnum) {
+    ColorCodeEnum["RED"] = "red";
+    ColorCodeEnum["PINK"] = "pink";
+    ColorCodeEnum["WHITE"] = "white";
+    ColorCodeEnum["YELLOW"] = "yellow";
+    ColorCodeEnum["ORANGE"] = "orange";
+    ColorCodeEnum["PURPLE"] = "purple";
+    ColorCodeEnum["BLUE"] = "blue";
+    ColorCodeEnum["LIGHT_BLUE"] = "light-blue";
+    ColorCodeEnum["GREEN"] = "green";
+    ColorCodeEnum["MINT"] = "mint";
+    ColorCodeEnum["CREAM"] = "cream";
+    ColorCodeEnum["PEACH"] = "peach";
+    ColorCodeEnum["BURGUNDY"] = "burgundy";
+    ColorCodeEnum["LAVENDER"] = "lavender";
+    ColorCodeEnum["CORAL"] = "coral";
+    ColorCodeEnum["BLACK"] = "black";
+    ColorCodeEnum["BROWN"] = "brown";
+    ColorCodeEnum["GOLD"] = "gold";
+    ColorCodeEnum["SILVER"] = "silver";
+    ColorCodeEnum["BEIGE"] = "beige";
+    ColorCodeEnum["MIX"] = "mix";
+})(ColorCodeEnum || (exports.ColorCodeEnum = ColorCodeEnum = {}));
+const COLOR_CODE_KEYS = Object.keys(ColorCodeEnum);
+exports.COLOR_CODE_LIST = COLOR_CODE_KEYS.map(k => ColorCodeEnum[k]);
+const isColorCode = (value) => {
+    if (typeof value !== 'string')
+        return false;
+    const list = exports.COLOR_CODE_LIST;
+    return list.indexOf(value) !== -1;
+};
+exports.isColorCode = isColorCode;

package/build/enum/index.js

@@ -80,6 +80,7 @@ __exportStar(require("./order-delivery-status.enum"), exports);
 __exportStar(require("./consignment-write-off-archives-status.enum"), exports);
 __exportStar(require("./context-message-context-type.enum"), exports);
 __exportStar(require("./country-code.enum"), exports);
+__exportStar(require("./color-code.enum"), exports);
 __exportStar(require("./pre-order-aggregation-mode.enum"), exports);
 __exportStar(require("./order-webshop-available-status-list"), exports);
 __exportStar(require("./transaction-type-groups"), exports);

package/commands/integration/moysklad/get-moysklad-status.query.ts

@@ -14,6 +14,14 @@ const GetMoyskladStatusResponseSchema = z.object({
         nameProcessingConvention: z.nativeEnum(ConsignmentImportNameConventionEnum).nullable(),
         isRemoveSizeFromName: z.boolean(),
         isCutCategoryFromName: z.boolean(),
+        lastStockSyncedAt: z.string().datetime().nullable(),
+        stockSyncStatus: z.enum(['PENDING', 'RUNNING', 'DEAD', 'IDLE']),
+        stockSyncDeadInfo: z
+            .object({
+                errorCode: z.string(),
+                errorMessage: z.string(),
+            })
+            .nullable(),
     }),
 });
 

package/commands/integration/moysklad/get-order-sync-status.query.ts

@@ -0,0 +1,41 @@
+import { z } from 'zod';
+import { OutboundSyncIntentEnum } from '../../../enum/outbound-sync-intent.enum';
+
+const PendingJobSchema = z.object({
+    intent: z.nativeEnum(OutboundSyncIntentEnum),
+    attempts: z.number().int().nonnegative(),
+    errorCode: z.string().nullable(),
+    errorMessage: z.string().nullable(),
+    nextAttemptAt: z.string().datetime(),
+});
+
+const DeadJobSchema = z.object({
+    intent: z.nativeEnum(OutboundSyncIntentEnum),
+    errorCode: z.string(),
+    errorMessage: z.string(),
+});
+
+const OrderSyncStatusSchema = z.object({
+    orderUUID: z.string().uuid(),
+    isLinked: z.boolean(),
+    externalHref: z.string().nullable(),
+    isClientLinked: z.boolean(),
+    hasUnlinkedProducts: z.boolean(),
+    missingProductUUIDs: z.array(z.string().uuid()),
+    lastSyncedAt: z.string().datetime().nullable(),
+    pendingJob: PendingJobSchema.nullable(),
+    isDead: z.boolean(),
+    deadJob: DeadJobSchema.nullable(),
+});
+
+const GetOrderSyncStatusResponseSchema = z.object({
+    message: z.string().optional(),
+    data: OrderSyncStatusSchema,
+});
+
+export namespace GetOrderSyncStatusContractQuery {
+    export const ResponseSchema = GetOrderSyncStatusResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export const StatusSchema = OrderSyncStatusSchema;
+    export type Status = z.infer<typeof OrderSyncStatusSchema>;
+}

package/commands/integration/moysklad/get-orders-batch-sync-status.query.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+
+const GetOrdersBatchSyncStatusRequestSchema = z.object({
+    orderUUIDs: z.array(z.string().uuid()).min(1).max(200),
+});
+
+const OrderSyncStatusSlimSchema = z.object({
+    orderUUID: z.string().uuid(),
+    isLinked: z.boolean(),
+    hasIssues: z.boolean(),
+});
+
+const GetOrdersBatchSyncStatusResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        statuses: z.array(OrderSyncStatusSlimSchema),
+    }),
+});
+
+export namespace GetOrdersBatchSyncStatusContractQuery {
+    export const RequestSchema = GetOrdersBatchSyncStatusRequestSchema;
+    export type Request = z.infer<typeof RequestSchema>;
+    export const ResponseSchema = GetOrdersBatchSyncStatusResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+    export const SlimStatusSchema = OrderSyncStatusSlimSchema;
+    export type SlimStatus = z.infer<typeof OrderSyncStatusSlimSchema>;
+}

package/commands/integration/moysklad/index.ts

@@ -8,3 +8,6 @@ export * from './scan-moysklad-import.query';
 export * from './execute-moysklad-import.command';
 export * from './scan-moysklad-clients-import.query';
 export * from './execute-moysklad-clients-import.command';
+export * from './get-order-sync-status.query';
+export * from './get-orders-batch-sync-status.query';
+export * from './sync-moysklad-stock.command';

package/commands/integration/moysklad/sync-moysklad-stock.command.ts

@@ -0,0 +1,15 @@
+import { z } from 'zod';
+
+const SyncMoyskladStockResponseSchema = z.object({
+    message: z.string().optional(),
+    data: z.object({
+        jobUUID: z.string().uuid(),
+        status: z.enum(['PENDING', 'RUNNING']),
+        wasAlreadyQueued: z.boolean(),
+    }),
+});
+
+export namespace SyncMoyskladStockContractCommand {
+    export const ResponseSchema = SyncMoyskladStockResponseSchema;
+    export type Response = z.infer<typeof ResponseSchema>;
+}

package/constant/error.ts

@@ -1046,7 +1046,11 @@ export const ERRORS = {
     MOYSKLAD_NOT_CONNECTED: { code: 'MS003', message: 'MoySklad integration is not connected for this company', httpCode: 404 },
     MOYSKLAD_API_ERROR: { code: 'MS004', message: 'MoySklad API request failed', httpCode: 502 },
     MOYSKLAD_DISCONNECT_FAILED: { code: 'MS005', message: 'Failed to disconnect MoySklad integration', httpCode: 500 },
-    MOYSKLAD_SETTINGS_INVALID: { code: 'MS006', message: 'Provided organization or store does not belong to the connected MoySklad account', httpCode: 400 },
+    MOYSKLAD_SETTINGS_INVALID: {
+        code: 'MS006',
+        message: 'Provided organization or store does not belong to the connected MoySklad account',
+        httpCode: 400,
+    },
     INTEGRATION_ENC_KEY_NOT_SET: { code: 'MS007', message: 'Integration encryption key is not configured on the server', httpCode: 500 },
     MOYSKLAD_IMPORT_IN_PROGRESS: { code: 'MS008', message: 'MoySklad import is already in progress for this company', httpCode: 409 },
     MOYSKLAD_CLIENTS_IMPORT_IN_PROGRESS: {
@@ -1064,11 +1068,6 @@ export const ERRORS = {
         message: 'Order client has no MoySklad link; import clients first',
         httpCode: 400,
     },
-    MOYSKLAD_ORDER_PRODUCT_NOT_LINKED: {
-        code: 'MS012',
-        message: 'One or more order products have no MoySklad link',
-        httpCode: 400,
-    },
     MOYSKLAD_INTEGRATION_INCOMPLETE: {
         code: 'MS013',
         message: 'MoySklad integration is missing default organization or store',
@@ -1094,4 +1093,19 @@ export const ERRORS = {
         message: 'Outbound sync entity type is not supported by this provider',
         httpCode: 400,
     },
+    MOYSKLAD_STOCK_SYNC_CAP_EXCEEDED: {
+        code: 'MS015',
+        message: 'MoySklad stock-sync concurrency cap exceeded; will retry shortly',
+        httpCode: 429,
+    },
+    MOYSKLAD_STOCK_SYNC_LOCK_BUSY: {
+        code: 'MS016',
+        message: 'MoySklad sync lock is held by another job for this company; will retry shortly',
+        httpCode: 409,
+    },
+    MOYSKLAD_INTEGRATION_DISABLED: {
+        code: 'MS017',
+        message: 'MoySklad integration is disabled for this company',
+        httpCode: 409,
+    },
 } as const;

package/enum/color-code.enum.ts

@@ -0,0 +1,32 @@
+export enum ColorCodeEnum {
+    RED = 'red',
+    PINK = 'pink',
+    WHITE = 'white',
+    YELLOW = 'yellow',
+    ORANGE = 'orange',
+    PURPLE = 'purple',
+    BLUE = 'blue',
+    LIGHT_BLUE = 'light-blue',
+    GREEN = 'green',
+    MINT = 'mint',
+    CREAM = 'cream',
+    PEACH = 'peach',
+    BURGUNDY = 'burgundy',
+    LAVENDER = 'lavender',
+    CORAL = 'coral',
+    BLACK = 'black',
+    BROWN = 'brown',
+    GOLD = 'gold',
+    SILVER = 'silver',
+    BEIGE = 'beige',
+    MIX = 'mix',
+}
+
+const COLOR_CODE_KEYS = Object.keys(ColorCodeEnum) as Array<keyof typeof ColorCodeEnum>;
+export const COLOR_CODE_LIST: readonly ColorCodeEnum[] = COLOR_CODE_KEYS.map(k => ColorCodeEnum[k]) as readonly ColorCodeEnum[];
+
+export const isColorCode = (value: unknown): value is ColorCodeEnum => {
+    if (typeof value !== 'string') return false;
+    const list = COLOR_CODE_LIST as readonly string[];
+    return list.indexOf(value) !== -1;
+};

package/enum/index.ts

@@ -64,6 +64,7 @@ export * from './order-delivery-status.enum';
 export * from './consignment-write-off-archives-status.enum';
 export * from './context-message-context-type.enum';
 export * from './country-code.enum';
+export * from './color-code.enum';
 export * from './pre-order-aggregation-mode.enum';
 export * from './order-webshop-available-status-list';
 export * from './transaction-type-groups';

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@floristcloud/api-lib",
-    "version": "1.2.25",
+    "version": "1.2.27",
     "description": "",
     "main": "./build/index.js",
     "scripts": {