@deliverart/sdk-js-integration 0.0.1

package/src/service-schemas/glovo.ts

@@ -0,0 +1,153 @@
+import {
+  datetimeSchema,
+  sortDirSchema,
+  timestampsFilterSchema,
+} from '@deliverart/sdk-js-global-types'
+import { z } from 'zod'
+
+import {
+  integrationBaseSchema,
+  integrationDeliveryProviderCommonSchema,
+  integrationDetailsFieldsSchema,
+} from '../schemas'
+import {
+  integrationDeliverooPathSchema,
+  integrationGlovoMenuUpdateStatusSchema,
+  integrationGlovoPathSchema,
+  integrationGlovoWebhookEventTypeSchema,
+  integrationServiceSchema,
+  integrationStatusSchema,
+} from '../types'
+
+export const integrationGlovoSchema = integrationBaseSchema
+  .omit({ service: true })
+  .extend(integrationDeliveryProviderCommonSchema.shape)
+  .extend({
+    storeId: z.string(),
+    locale: z.string(),
+    pendingMenuChanges: z.boolean(),
+    service: integrationServiceSchema.extract(['glovo']),
+  })
+export type IntegrationGlovo = z.infer<typeof integrationGlovoSchema>
+
+export const integrationGlovoDetailsSchema = integrationGlovoSchema.extend(
+  integrationDetailsFieldsSchema.shape,
+)
+export type IntegrationGlovoDetails = z.infer<typeof integrationGlovoDetailsSchema>
+
+export const integrationGlovoEditableFieldsSchema = integrationGlovoSchema
+  .pick({
+    name: true,
+    storeId: true,
+    locale: true,
+    skipNegativePrices: true,
+    skipInvalidItem: true,
+    salesMode: true,
+    importTaggedItems: true,
+    tagsForImport: true,
+    provider: true,
+  })
+  .partial()
+export type IntegrationGlovoEditableFields = z.infer<typeof integrationGlovoEditableFieldsSchema>
+
+export const integrationsGlovoQuerySchema = z
+  .object({
+    'order[createdAt]': sortDirSchema.optional(),
+    'order[updatedAt]': sortDirSchema.optional(),
+    'order[latestMenuCheckAt]': sortDirSchema.optional(),
+    'order[latestMenuSyncAt]': sortDirSchema.optional(),
+    name: z.string().optional(),
+    storeId: z.string().optional(),
+    'storeId[]': z.array(z.string()).optional(),
+    status: integrationStatusSchema.optional(),
+    'status[]': z.array(integrationStatusSchema).optional(),
+    connectionId: z.string().optional(),
+    'connectionId[]': z.array(z.string()).optional(),
+    skipInvalidItem: z.coerce.boolean().optional(),
+    isValidMenu: z.coerce.boolean().optional(),
+    'latestMenuCheckAt[before]': z.string().optional(),
+    'latestMenuCheckAt[strictly_before]': z.string().optional(),
+    'latestMenuCheckAt[after]': z.string().optional(),
+    'latestMenuCheckAt[strictly_after]': z.string().optional(),
+    'latestMenuSyncAt[before]': z.string().optional(),
+    'latestMenuSyncAt[strictly_before]': z.string().optional(),
+    'latestMenuSyncAt[after]': z.string().optional(),
+    'latestMenuSyncAt[strictly_after]': z.string().optional(),
+    service: integrationServiceSchema.extract(['glovo']).optional(),
+    page: z.coerce.number().optional(),
+  })
+  .merge(timestampsFilterSchema)
+export type IntegrationsGlovoQueryParams = z.infer<typeof integrationsGlovoQuerySchema>
+
+export const integrationGlovoWebhookEventSchema = z.object({
+  id: z.string(),
+  event: integrationGlovoWebhookEventTypeSchema,
+  body: z.any(),
+  createdAt: datetimeSchema,
+})
+export type IntegrationGlovoWebhookEvent = z.infer<typeof integrationGlovoWebhookEventSchema>
+export const integrationGlovoWebhookEventDetailsSchema = integrationGlovoWebhookEventSchema.extend({
+  integration: integrationGlovoPathSchema,
+})
+export type IntegrationGlovoWebhookEventDetails = z.infer<
+  typeof integrationGlovoWebhookEventDetailsSchema
+>
+
+export const integrationGlovoWebhookEventsQueryParamsSchema = z.object({
+  'order[createdAt]': sortDirSchema.optional(),
+  event: integrationGlovoWebhookEventTypeSchema.optional(),
+  'event[]': z.array(integrationGlovoWebhookEventTypeSchema).optional(),
+  'createdAt[before]': z.string().optional(),
+  'createdAt[strictly_before]': z.string().optional(),
+  'createdAt[after]': z.string().optional(),
+  'createdAt[strictly_after]': z.string().optional(),
+  page: z.coerce.number().optional(),
+})
+export type IntegrationGlovoWebhookEventsQueryParams = z.infer<
+  typeof integrationGlovoWebhookEventsQueryParamsSchema
+>
+
+export const integrationGlovoMenuUpdateSchema = z.object({
+  id: z.string(),
+  transactionId: z.string().nullable(),
+  status: integrationGlovoMenuUpdateStatusSchema.nullable(),
+  retryCompleted: z.boolean(),
+  createdAt: datetimeSchema,
+  responseAt: datetimeSchema.nullable(),
+  latestCheckAt: datetimeSchema.nullable(),
+})
+export type IntegrationGlovoMenuUpdate = z.infer<typeof integrationGlovoMenuUpdateSchema>
+export const integrationGlovoMenuUpdateDetailsSchema = integrationGlovoMenuUpdateSchema.extend({
+  integration: integrationDeliverooPathSchema,
+  details: z.any().nullable(),
+})
+export type IntegrationGlovoMenuUpdateDetails = z.infer<
+  typeof integrationGlovoMenuUpdateDetailsSchema
+>
+
+export const integrationGlovoMenuUpdatesQuerySchema = z.object({
+  'order[createdAt]': sortDirSchema.optional(),
+  'order[responseAt]': sortDirSchema.optional(),
+  'order[latestCheckAt]': sortDirSchema.optional(),
+  retryCompleted: z.coerce.boolean().optional(),
+  transactionId: z.string().optional(),
+  'transactionId[]': z.array(z.string()).optional(),
+  status: integrationGlovoMenuUpdateStatusSchema.optional(),
+  'status[]': z.array(integrationGlovoMenuUpdateStatusSchema).optional(),
+  'createdAt[before]': z.string().optional(),
+  'createdAt[strictly_before]': z.string().optional(),
+  'createdAt[after]': z.string().optional(),
+  'createdAt[strictly_after]': z.string().optional(),
+  'responseAt[before]': z.string().optional(),
+  'responseAt[strictly_before]': z.string().optional(),
+  'responseAt[after]': z.string().optional(),
+  'responseAt[strictly_after]': z.string().optional(),
+  'latestCheckAt[before]': z.string().optional(),
+  'latestCheckAt[strictly_before]': z.string().optional(),
+  'latestCheckAt[after]': z.string().optional(),
+  'latestCheckAt[strictly_after]': z.string().optional(),
+  page: z.coerce.number().optional(),
+})
+export type IntegrationGlovoMenuUpdatesQueryParams = z.infer<
+  typeof integrationGlovoMenuUpdatesQuerySchema
+>

package/src/service-schemas/justeat.ts

@@ -0,0 +1,121 @@
+import {
+  datetimeSchema,
+  sortDirSchema,
+  timestampsFilterSchema,
+} from '@deliverart/sdk-js-global-types'
+import { z } from 'zod'
+
+import {
+  integrationBaseSchema,
+  integrationDeliveryProviderCommonSchema,
+  integrationDetailsFieldsSchema,
+} from '../schemas'
+import {
+  integrationJustEatPathSchema,
+  integrationJustEatSyncTypeSchema,
+  integrationServiceSchema,
+  integrationStatusSchema,
+} from '../types'
+
+export const integrationJustEatSchema = integrationBaseSchema
+  .omit({ service: true })
+  .extend(integrationDeliveryProviderCommonSchema.shape)
+  .extend({
+    syncType: integrationJustEatSyncTypeSchema,
+    defaultLanguage: z.string(),
+    restaurantId: z.string(),
+    latestOpeningTimesSyncAt: datetimeSchema,
+    service: integrationServiceSchema.extract(['justeat']),
+    autoAcceptOrders: z.boolean(),
+    nextSyncMenuScheduledAt: datetimeSchema.nullable(),
+  })
+export type IntegrationJustEat = z.infer<typeof integrationJustEatSchema>
+
+export const integrationJustEatDetailsSchema = integrationJustEatSchema.extend(
+  integrationDetailsFieldsSchema.shape,
+)
+export type IntegrationJustEatDetails = z.infer<typeof integrationJustEatDetailsSchema>
+
+export const integrationJustEatEditableFieldsSchema = integrationJustEatSchema
+  .pick({
+    name: true,
+    provider: true,
+    syncType: true,
+    defaultLanguage: true,
+    restaurantId: true,
+    skipNegativePrices: true,
+    skipInvalidItem: true,
+    autoAcceptOrders: true,
+    importTaggedItems: true,
+    tagsForImport: true,
+  })
+  .partial()
+export type IntegrationJustEatEditableFields = z.infer<
+  typeof integrationJustEatEditableFieldsSchema
+>
+
+export const integrationsJustEatQuerySchema = z
+  .object({
+    'order[createdAt]': sortDirSchema.optional(),
+    'order[updatedAt]': sortDirSchema.optional(),
+    'order[latestMenuCheckAt]': sortDirSchema.optional(),
+    'order[latestMenuSyncAt]': sortDirSchema.optional(),
+    'order[latestOpeningTimesSyncAt]': sortDirSchema.optional(),
+    'order[nextSyncMenuScheduledAt]': sortDirSchema.optional(),
+    name: z.string().optional(),
+    restaurantId: z.string().optional(),
+    'restaurantId[]': z.array(z.string()).optional(),
+    status: integrationStatusSchema.optional(),
+    'status[]': z.array(integrationStatusSchema).optional(),
+    syncType: integrationJustEatPathSchema.optional(),
+    'syncType[]': z.array(integrationJustEatPathSchema).optional(),
+    connectionId: z.string().optional(),
+    'connectionId[]': z.array(z.string()).optional(),
+    skipInvalidItem: z.coerce.boolean().optional(),
+    isValidMenu: z.coerce.boolean().optional(),
+    'latestMenuCheckAt[before]': z.string().optional(),
+    'latestMenuCheckAt[strictly_before]': z.string().optional(),
+    'latestMenuCheckAt[after]': z.string().optional(),
+    'latestMenuCheckAt[strictly_after]': z.string().optional(),
+    'latestMenuSyncAt[before]': z.string().optional(),
+    'latestMenuSyncAt[strictly_before]': z.string().optional(),
+    'latestMenuSyncAt[after]': z.string().optional(),
+    'latestMenuSyncAt[strictly_after]': z.string().optional(),
+    'latestOpeningTimesSyncAt[before]': z.string().optional(),
+    'latestOpeningTimesSyncAt[strictly_before]': z.string().optional(),
+    'latestOpeningTimesSyncAt[after]': z.string().optional(),
+    'latestOpeningTimesSyncAt[strictly_after]': z.string().optional(),
+    'nextSyncMenuScheduledAt[before]': z.string().optional(),
+    'nextSyncMenuScheduledAt[strictly_before]': z.string().optional(),
+    'nextSyncMenuScheduledAt[after]': z.string().optional(),
+    'nextSyncMenuScheduledAt[strictly_after]': z.string().optional(),
+    service: integrationServiceSchema.extract(['justeat']).optional(),
+    page: z.coerce.number().optional(),
+  })
+  .merge(timestampsFilterSchema)
+export type IntegrationsJustEatQueryParams = z.infer<typeof integrationsJustEatQuerySchema>
+
+export const integrationJustEatSyncMenuProcessSchema = z.object({
+  id: z.string(),
+  ingestionSucceeded: z.boolean().nullable(),
+  error: z.any().nullable(),
+  createdAt: datetimeSchema,
+})
+export type IntegrationJustEatSyncMenuProcess = z.infer<
+  typeof integrationJustEatSyncMenuProcessSchema
+>
+export const integrationJustEatSyncMenuProcessDetailsSchema =
+  integrationJustEatSyncMenuProcessSchema.extend({
+    integration: integrationJustEatPathSchema,
+  })
+export type IntegrationJustEatSyncMenuProcessDetails = z.infer<
+  typeof integrationJustEatSyncMenuProcessDetailsSchema
+>
+
+export const integrationJustEatSyncMenuProcessesQuerySchema = z.object({
+  'order[createdAt]': sortDirSchema.optional(),
+  page: z.coerce.number().optional(),
+})
+export type IntegrationJustEatSyncMenuProcessesQueryParams = z.infer<
+  typeof integrationJustEatSyncMenuProcessesQuerySchema
+>

package/src/types.ts

@@ -0,0 +1,227 @@
+import { z } from 'zod'
+
+export const integrationStatuses = ['pending', 'active', 'deleting'] as const
+export const integrationStatusSchema = z.enum(integrationStatuses)
+export type IntegrationStatus = z.infer<typeof integrationStatusSchema>
+
+export const integrationProviders = ['deliverart', 'cassa_in_cloud'] as const
+export const integrationProviderSchema = z.enum(integrationProviders)
+export type IntegrationProvider = z.infer<typeof integrationProviderSchema>
+
+export const integrationServices = ['deliveroo', 'justeat', 'glovo', 'cassa_in_cloud'] as const
+export const integrationServiceSchema = z.enum(integrationServices)
+export type IntegrationService = z.infer<typeof integrationServiceSchema>
+
+export const integrationClientLogRequestMethods = ['DELETE', 'GET', 'PATCH', 'POST', 'PUT'] as const
+export const integrationClientLogRequestMethodSchema = z.enum(integrationClientLogRequestMethods)
+export type IntegrationClientLogRequestMethod = z.infer<
+  typeof integrationClientLogRequestMethodSchema
+>
+
+export const integrationJustEatSyncTypes = ['ALL', 'DELIVERY', 'TAKE_AWAY'] as const
+export const integrationJustEatSyncTypeSchema = z.enum(integrationJustEatSyncTypes)
+export type IntegrationJustEatSyncType = z.infer<typeof integrationJustEatSyncTypeSchema>
+
+export const integrationJustEatRestaurantStatuses = ['OPEN', 'CLOSED'] as const
+export const integrationJustEatRestaurantStatusSchema = z.enum(integrationJustEatRestaurantStatuses)
+export type IntegrationJustEatRestaurantStatus = z.infer<
+  typeof integrationJustEatRestaurantStatusSchema
+>
+
+export const integrationDeliverooSiteStatuses = ['OPEN', 'CLOSED'] as const
+export const integrationDeliverooSiteStatusSchema = z.enum(integrationDeliverooSiteStatuses)
+export type IntegrationDeliverooSiteStatus = z.infer<typeof integrationDeliverooSiteStatusSchema>
+
+export const integrationDeliverooSyncMenuProcessModes = ['menu', 'item_availabilities'] as const
+export const integrationDeliverooSyncMenuProcessModeSchema = z.enum(
+  integrationDeliverooSyncMenuProcessModes,
+)
+export type IntegrationDeliverooSyncMenuProcessMode = z.infer<
+  typeof integrationDeliverooSyncMenuProcessModeSchema
+>
+
+export const integrationDeliverooWebhookEventTypes = [
+  'order.new',
+  'order.status_update',
+  'rider.status_update',
+  'menu.upload_result',
+] as const
+export const integrationDeliverooWebhookEventTypeSchema = z.enum(
+  integrationDeliverooWebhookEventTypes,
+)
+export type IntegrationDeliverooWebhookEventType = z.infer<
+  typeof integrationDeliverooWebhookEventTypeSchema
+>
+
+export const integrationGlovoMenuUpdateStatuses = [
+  'SUCCESS',
+  'PROCESSING',
+  'FETCH_MENU_INVALID_PAYLOAD',
+  'FETCH_MENU_SERVER_ERROR',
+  'FETCH_MENU_UNAUTHORIZED',
+  'NOT_PROCESSED',
+  'LIMIT_EXCEEDED',
+  'GLOVO_ERROR',
+  'SCHEDULE_CATALOG_DISABLED',
+] as const
+export const integrationGlovoMenuUpdateStatusSchema = z.enum(integrationGlovoMenuUpdateStatuses)
+export type IntegrationGlovoMenuUpdateStatus = z.infer<
+  typeof integrationGlovoMenuUpdateStatusSchema
+>
+
+export const integrationGlovoStoreStatuses = ['OPEN', 'CLOSED'] as const
+export const integrationGlovoStoreStatusSchema = z.enum(integrationGlovoStoreStatuses)
+export type IntegrationGlovoStoreStatus = z.infer<typeof integrationGlovoStoreStatusSchema>
+
+export const integrationGlovoWebhookEventTypes = ['order.dispatched', 'order.cancelled'] as const
+export const integrationGlovoWebhookEventTypeSchema = z.enum(integrationGlovoWebhookEventTypes)
+export type IntegrationGlovoWebhookEventType = z.infer<
+  typeof integrationGlovoWebhookEventTypeSchema
+>
+
+export const integrationCassaInCloudDirections = [
+  'EXTERNAL_TO_INTERNAL',
+  'INTERNAL_TO_EXTERNAL',
+] as const
+export const integrationCassaInCloudDirectionSchema = z.enum(integrationCassaInCloudDirections)
+export type IntegrationCassaInCloudDirection = z.infer<
+  typeof integrationCassaInCloudDirectionSchema
+>
+
+export const integrationCassaInCloudProductChannels = [
+  'RISTO',
+  'SALE',
+  'ECOMMERCE',
+  'MOBILE_COMMERCE',
+  'SELF_ORDER',
+  'KIOSK',
+] as const
+export const integrationCassaInCloudProductChannelSchema = z.enum(
+  integrationCassaInCloudProductChannels,
+)
+export type IntegrationCassaInCloudProductChannel = z.infer<
+  typeof integrationCassaInCloudProductChannelSchema
+>
+
+export const integrationCassaInCloudWebHookEventEntities = [
+  'BILL',
+  'RECEIPT',
+  'CREDIT_NOTE',
+  'INVOICE',
+  'DDT',
+  'ORDER',
+  'QUOTATION',
+  'RECONCILIATION',
+  'STOCK_MOVEMENT',
+  'CUSTOMER',
+  'ORGANIZATION',
+] as const
+export const integrationCassaInCloudWebHookEventEntitySchema = z.enum(
+  integrationCassaInCloudWebHookEventEntities,
+)
+export type IntegrationCassaInCloudWebHookEventEntity = z.infer<
+  typeof integrationCassaInCloudWebHookEventEntitySchema
+>
+
+export const integrationCassaInCloudWebHookEventEvents = ['CREATE', 'UPDATE', 'DELETE'] as const
+export const integrationCassaInCloudWebHookEventEventSchema = z.enum(
+  integrationCassaInCloudWebHookEventEvents,
+)
+export type IntegrationCassaInCloudWebHookEventEvent = z.infer<
+  typeof integrationCassaInCloudWebHookEventEventSchema
+>
+
+function createIntegrationPathSchemas(service: IntegrationService) {
+  const regex = new RegExp(`^/integrations/${service}/[a-z_]+/[0-9a-fA-F-]{36}$`)
+
+  const pathSchema = z.string().refine(val => regex.test(val), {
+    message: `Invalid integration ${service} path format`,
+  })
+
+  const nullablePathSchema = z
+    .string()
+    .nullable()
+    .refine(val => val == null || regex.test(val), {
+      message: `Invalid integration ${service} path format`,
+    })
+
+  return { pathSchema, nullablePathSchema }
+}
+
+export const integrationPathSchemas = Object.fromEntries(
+  integrationServices.map(service => [service, createIntegrationPathSchemas(service)]),
+) as Record<IntegrationService, ReturnType<typeof createIntegrationPathSchemas>>
+
+export const integrationDeliverooPathSchema = integrationPathSchemas.deliveroo.pathSchema
+export const integrationDeliverooNullablePathSchema =
+  integrationPathSchemas.deliveroo.nullablePathSchema
+export type IntegrationDeliverooPath = z.infer<typeof integrationDeliverooPathSchema>
+export type IntegrationDeliverooNullablePath = z.infer<
+  typeof integrationDeliverooNullablePathSchema
+>
+
+export const integrationGlovoPathSchema = integrationPathSchemas.glovo.pathSchema
+export const integrationGlovoNullablePathSchema = integrationPathSchemas.glovo.nullablePathSchema
+export type IntegrationGlovoPath = z.infer<typeof integrationGlovoPathSchema>
+export type IntegrationGlovoNullablePath = z.infer<typeof integrationGlovoNullablePathSchema>
+
+export const integrationJustEatPathSchema = integrationPathSchemas.justeat.pathSchema
+export const integrationJustEatNullablePathSchema =
+  integrationPathSchemas.justeat.nullablePathSchema
+export type IntegrationJustEatPath = z.infer<typeof integrationJustEatPathSchema>
+export type IntegrationJustEatNullablePath = z.infer<typeof integrationJustEatNullablePathSchema>
+
+export const integrationCassaInCloudPathSchema = integrationPathSchemas.cassa_in_cloud.pathSchema
+export const integrationCassaInCloudNullablePathSchema =
+  integrationPathSchemas.cassa_in_cloud.nullablePathSchema
+export type IntegrationCassaInCloudPath = z.infer<typeof integrationCassaInCloudPathSchema>
+export type IntegrationCassaInCloudNullablePath = z.infer<
+  typeof integrationCassaInCloudNullablePathSchema
+>
+
+export const integrationPathSchema = z
+  .string()
+  .refine(val => /^\/integrations\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+    message: 'Invalid integration path format',
+  })
+export type IntegrationPath = z.infer<typeof integrationPathSchema>
+
+export const integrationNullablePathSchema = z
+  .string()
+  .nullable()
+  .refine(val => val == null || /^\/integrations\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(val), {
+    message: 'Invalid integration path format',
+  })
+export type IntegrationNullablePath = z.infer<typeof integrationNullablePathSchema>
+
+export const integrationCassaInCloudSyncMenuErrorLogPathSchema = z
+  .string()
+  .refine(
+    val =>
+      /^\/integrations\/cassa_in_cloud\/[a-z_]+\/[0-9a-fA-F-]{36}\/sync_menu_processes\/[a-z_]+\/[0-9a-fA-F-]{36}\/error_logs\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(
+        val,
+      ),
+    {
+      message: 'Invalid integration path format',
+    },
+  )
+export type IntegrationCassaInCloudSyncMenuErrorLogPath = z.infer<
+  typeof integrationCassaInCloudSyncMenuErrorLogPathSchema
+>
+
+export const integrationCassaInCloudSyncMenuErrorLogNullablePathSchema = z
+  .string()
+  .nullable()
+  .refine(
+    val =>
+      val == null ||
+      /^\/integrations\/cassa_in_cloud\/[a-z_]+\/[0-9a-fA-F-]{36}\/sync_menu_processes\/[a-z_]+\/[0-9a-fA-F-]{36}\/error_logs\/[a-z_]+\/[0-9a-fA-F-]{36}$/.test(
+        val,
+      ),
+    {
+      message: 'Invalid integration path format',
+    },
+  )
+export type IntegrationCassaInCloudSyncMenuErrorLogNullablePath = z.infer<
+  typeof integrationCassaInCloudSyncMenuErrorLogNullablePathSchema
+>

package/tsconfig.json

@@ -0,0 +1,15 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Node",
+    "esModuleInterop": true,
+    "forceConsistentCasingInFileNames": true,
+    "strict": true,
+    "skipLibCheck": true,
+    "outDir": "dist",
+    "declaration": true,
+    "declarationMap": true
+  },
+  "include": ["src"]
+}