@kl1/contracts 1.0.0

package/dist/index.mjs

@@ -0,0 +1,817 @@
+// src/contract.ts
+import { initContract as initContract10 } from "@ts-rest/core";
+
+// src/auth/index.ts
+import { initContract } from "@ts-rest/core";
+import { z as z5 } from "zod";
+
+// src/base-contract.ts
+import z from "zod";
+var DefaultHeaderSchema = z.object({
+  // biome-ignore lint/style/useNamingConvention: <explanation>
+  "x-tenant": z.string({ required_error: "Tenant id is required" }),
+  authorization: z.string()
+});
+var DefaultEntitySchema = z.object({
+  id: z.string().uuid(),
+  createdAt: z.date(),
+  updatedAt: z.date(),
+  deletedAt: z.date()
+});
+var DefaultQueryParamsSchema = z.object({
+  page: z.number().positive().default(1),
+  pageSize: z.number().positive().default(10)
+});
+var DefaultSuccessResponseSchema = z.object({
+  requestId: z.string()
+});
+var DefaultErrorResponseSchema = z.object({
+  message: z.string(),
+  error: z.any()
+});
+var DefaultNotFoundSchema = DefaultErrorResponseSchema;
+var DefaultUnprocessibleSchema = DefaultErrorResponseSchema;
+var DefaultUnauthorizedSchema = DefaultErrorResponseSchema;
+var defaultResponses = {
+  401: DefaultUnauthorizedSchema,
+  404: DefaultNotFoundSchema,
+  422: DefaultUnprocessibleSchema
+};
+
+// src/user/schema.ts
+import z4 from "zod";
+
+// src/role/schema.ts
+import z3 from "zod";
+
+// src/permission/schema.ts
+import z2 from "zod";
+var PermissionSchema = DefaultEntitySchema.extend({
+  systemName: z2.string(),
+  displayName: z2.string(),
+  description: z2.string().nullable()
+});
+
+// src/role/schema.ts
+var RoleSchema = DefaultEntitySchema.extend({
+  systemName: z3.string(),
+  displayName: z3.string(),
+  description: z3.string().nullable(),
+  permissions: z3.array(PermissionSchema)
+});
+
+// src/user/schema.ts
+var UserSchema = DefaultEntitySchema.extend({
+  name: z4.string(),
+  email: z4.string().email(),
+  address: z4.string().nullable(),
+  phone: z4.string().nullable(),
+  notificationCount: z4.number().nullable(),
+  roles: z4.array(RoleSchema)
+});
+
+// src/auth/index.ts
+var authContract = initContract().router(
+  {
+    refreshToken: {
+      method: "POST",
+      path: "/refresh-token",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          accessToken: z5.string(),
+          refreshToken: z5.string()
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      body: null,
+      summary: "Refresh token"
+    },
+    exchangeToken: {
+      method: "POST",
+      path: "/exchange-token",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          accessToken: z5.string(),
+          refreshToken: z5.string()
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      body: null,
+      headers: DefaultHeaderSchema,
+      summary: "Exchange jwt token"
+    },
+    logout: {
+      method: "POST",
+      path: "/logout",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z5.string()
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      body: null,
+      summary: "Logout"
+    },
+    me: {
+      method: "GET",
+      path: "/me",
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          user: UserSchema
+        }),
+        401: DefaultUnauthorizedSchema,
+        404: DefaultNotFoundSchema,
+        422: DefaultUnprocessibleSchema
+      },
+      summary: "Get current user"
+    }
+  },
+  { pathPrefix: "auth" }
+);
+
+// src/mail/mail-contract.ts
+import { initContract as initContract6 } from "@ts-rest/core";
+
+// src/mail/room-contract.ts
+import { initContract as initContract2 } from "@ts-rest/core";
+import z6 from "zod";
+var roomContract = initContract2().router(
+  {
+    create: {
+      method: "POST",
+      path: "/",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z6.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Create a new room for new incoming mail"
+    },
+    get: {
+      method: "GET",
+      path: "/:id",
+      pathParams: z6.object({
+        id: z6.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z6.string()
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a mail room by id"
+    },
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z6.object({
+        id: z6.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z6.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Update a mail room by id"
+    },
+    delete: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z6.object({
+        id: z6.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z6.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete a mail room by id"
+    }
+  },
+  {
+    pathPrefix: "/room"
+  }
+);
+
+// src/mail/message-contract.ts
+import { initContract as initContract3 } from "@ts-rest/core";
+import z7 from "zod";
+var messageContract = initContract3().router(
+  {
+    create: {
+      method: "POST",
+      path: "/",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z7.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Add a new message into a room"
+    },
+    get: {
+      method: "GET",
+      path: "/:id",
+      pathParams: z7.object({
+        id: z7.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z7.string()
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a message by id"
+    },
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z7.object({
+        id: z7.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z7.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Update a message by id"
+    },
+    delete: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z7.object({
+        id: z7.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z7.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete a message by id"
+    }
+  },
+  {
+    pathPrefix: "/message"
+  }
+);
+
+// src/mail/account-contract.ts
+import { initContract as initContract4 } from "@ts-rest/core";
+import z9 from "zod";
+
+// src/mail/schemas/account.schema.ts
+import z8 from "zod";
+var mailServerSchema = z8.object({
+  id: z8.string(),
+  created_at: z8.string(),
+  updated_at: z8.string(),
+  deletedAt: z8.string().nullable(),
+  tenant_id: z8.string(),
+  name: z8.string(),
+  smtpHost: z8.string(),
+  smtpPort: z8.string(),
+  smtpTlsPort: z8.string(),
+  useTlsForSmtp: z8.boolean(),
+  imapHost: z8.string(),
+  imapPort: z8.string(),
+  imapTlsPort: z8.string(),
+  useTlsForImap: z8.boolean()
+});
+var mailAccountSchema = z8.object({
+  id: z8.string(),
+  created_at: z8.string(),
+  updated_at: z8.string(),
+  deletedAt: z8.date().nullable(),
+  tenant_id: z8.string(),
+  name: z8.string(),
+  address: z8.string(),
+  accountId: z8.string(),
+  mailServerId: z8.string(),
+  mailServer: mailServerSchema,
+  state: z8.union([
+    z8.literal("init"),
+    z8.literal("syncing"),
+    z8.literal("connecting"),
+    z8.literal("connected"),
+    z8.literal("disconnected"),
+    z8.literal("authenticationError"),
+    z8.literal("connectError"),
+    z8.literal("unset")
+  ])
+});
+var accountContractsSchemas = {
+  create: {
+    input: z8.object({
+      address: z8.string().email("Email address must be valid email."),
+      name: z8.string().min(1, "Account name cannot be empty."),
+      password: z8.string().min(1, "Password cannot be empty."),
+      mailServerId: z8.string().uuid("Invalid mail_server_id")
+    })
+  },
+  getById: {
+    input: z8.object({
+      id: z8.string().uuid()
+    }),
+    output: mailAccountSchema
+  },
+  getAll: {
+    output: z8.array(mailAccountSchema)
+  },
+  update: {
+    input: mailAccountSchema,
+    output: mailAccountSchema
+  },
+  disconnect: {
+    input: z8.object({
+      id: z8.string().uuid()
+    }),
+    output: mailAccountSchema
+  },
+  reconnect: {
+    input: z8.object({
+      id: z8.string()
+    }),
+    output: mailAccountSchema
+  },
+  delete: {
+    input: z8.object({
+      id: z8.string()
+    }),
+    output: mailAccountSchema
+  }
+};
+
+// src/mail/account-contract.ts
+var accountContract = initContract4().router(
+  {
+    //#region ........register account
+    create: {
+      method: "POST",
+      path: "",
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          // data: accountContractsSchemas.create.output,
+          message: z9.string()
+        }),
+        400: z9.object({
+          message: z9.string()
+        }),
+        409: z9.object({
+          message: z9.string()
+        }),
+        500: z9.object({
+          message: z9.string()
+        }),
+        ...defaultResponses
+      },
+      body: accountContractsSchemas.create.input,
+      summary: "Register a new mail account"
+    },
+    //#endregion register account
+    //#region ........get account
+    getById: {
+      method: "GET",
+      path: "/:id",
+      pathParams: accountContractsSchemas.getById.input,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.getById.output
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a account by id"
+    },
+    //#endregion get account
+    //#region ........get all account
+    //TODO: add pagination parameters
+    getAll: {
+      method: "GET",
+      path: "",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          data: z9.any()
+          // data: accountContractsSchemas.getAll.output,
+        }),
+        ...defaultResponses
+      },
+      summary: "Get al accounts"
+    },
+    //#endregion get all accounts
+    //#region ........update account
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z9.object({
+        id: z9.string().uuid()
+      }),
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.update.output
+        }),
+        ...defaultResponses
+      },
+      body: accountContractsSchemas.update.input.partial(),
+      summary: "Update a account by id"
+    },
+    //#endregion update account
+    //#region ........disconnect account
+    disconnect: {
+      method: "PATCH",
+      path: "/:id/disconnect",
+      pathParams: accountContractsSchemas.disconnect.input,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.disconnect.output
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Disconnect an account"
+    },
+    //#endregion disconnect account
+    //#region ........reconnect account
+    reconnect: {
+      method: "PATCH",
+      path: "/:id/reconnect",
+      pathParams: accountContractsSchemas.reconnect.input,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          data: accountContractsSchemas.reconnect.output
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Reconnect a disconncted account"
+    },
+    //#endregion reconnect account
+    //#region ........delete account
+    delete: {
+      method: "DELETE",
+      path: "/:id",
+      pathParams: accountContractsSchemas.delete.input,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z9.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete an account by id"
+    }
+    //#endregion delete account
+  },
+  {
+    baseHeaders: DefaultHeaderSchema,
+    pathPrefix: "mail/account"
+  }
+);
+
+// src/mail/mail-server.ts
+import { initContract as initContract5 } from "@ts-rest/core";
+import z10 from "zod";
+var serverContract = initContract5().router(
+  {
+    create: {
+      method: "POST",
+      path: "/",
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z10.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Register a new mail server"
+    },
+    get: {
+      method: "GET",
+      path: "/:id",
+      pathParams: z10.object({
+        id: z10.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z10.string()
+        }),
+        ...defaultResponses
+      },
+      summary: "Get a mail server by id"
+    },
+    update: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z10.object({
+        id: z10.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z10.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Update a mail server by id"
+    },
+    delete: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z10.object({
+        id: z10.string()
+      }),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          message: z10.string()
+        }),
+        ...defaultResponses
+      },
+      body: null,
+      summary: "Delete a mail server by id"
+    }
+  },
+  {
+    pathPrefix: "/server"
+  }
+);
+
+// src/mail/mail-contract.ts
+var mailContract = initContract6().router({
+  room: roomContract,
+  message: messageContract,
+  account: accountContract,
+  server: serverContract
+});
+
+// src/cx-log/index.ts
+import { initContract as initContract7 } from "@ts-rest/core";
+import z13 from "zod";
+
+// src/cx-log/schema.ts
+import z11 from "zod";
+var CxLogSchema = DefaultEntitySchema.extend({
+  caseId: z11.number(),
+  entityId: z11.string().uuid(),
+  entityName: z11.string(),
+  contactId: z11.string().uuid().nullable(),
+  channel: z11.string().nullable(),
+  queueId: z11.string().uuid().nullable(),
+  agentId: z11.string().uuid().nullable(),
+  direction: z11.string().nullable(),
+  startedDate: z11.date().nullable(),
+  handledTime: z11.number().nullable(),
+  firstResponseTime: z11.number().nullable(),
+  disposition: z11.string().nullable()
+});
+
+// src/cx-log/validation.ts
+import z12 from "zod";
+var CustomFieldQueryParamsSchema = z12.object({
+  attributeId: z12.string(),
+  value: z12.string().or(z12.array(z12.string())),
+  type: z12.string()
+});
+var GetAllCxLogQueryParamsSchema = DefaultQueryParamsSchema.extend({
+  contactId: z12.string().uuid().optional(),
+  channelIds: z12.string().uuid().optional(),
+  queueIds: z12.string().uuid().optional(),
+  direction: z12.enum(["inbound", "outbound"]).array().optional(),
+  sentimentScore: z12.enum(["positive", "negative"]).array().optional(),
+  csatScore: z12.string().optional(),
+  sla: z12.enum(["meet", "unmeet"]).array().optional(),
+  caseId: z12.string().optional(),
+  name: z12.string().optional(),
+  email: z12.string().optional(),
+  phone: z12.string().optional(),
+  address: z12.string().optional(),
+  company: z12.string().optional(),
+  agentIds: z12.string().array().optional(),
+  channel: z12.string().array().optional(),
+  disposition: z12.string().array().optional(),
+  notes: z12.string().optional(),
+  contactLabels: z12.string().array().optional(),
+  tags: z12.string().array().optional(),
+  selectedDate: z12.string().optional(),
+  customFields: z12.array(CustomFieldQueryParamsSchema).optional()
+});
+
+// src/cx-log/index.ts
+var cxLogContract = initContract7().router({
+  findAll: {
+    method: "GET",
+    path: "/cx-logs",
+    headers: DefaultHeaderSchema,
+    responses: {
+      200: DefaultSuccessResponseSchema.extend({
+        total: z13.number(),
+        page: z13.number(),
+        pageSize: z13.number(),
+        cxLogs: z13.array(CxLogSchema)
+      }),
+      401: DefaultUnauthorizedSchema
+    },
+    query: GetAllCxLogQueryParamsSchema,
+    summary: "Get all cx-logs"
+  }
+});
+
+// src/mail/email-engine-webhooks-events.contract.ts
+import { initContract as initContract8 } from "@ts-rest/core";
+import z14 from "zod";
+var emailEngineWebhooksEventsContract = initContract8().router({
+  handleWebhooksEvents: {
+    method: "POST",
+    path: "/email_engine/webhooks",
+    // we don't need to respone anything but added responses just for solving type error
+    responses: {
+      200: DefaultSuccessResponseSchema.extend({
+        message: z14.string()
+      })
+    },
+    body: null,
+    summary: "Handle email engine webhooks events such as authenticationSuccess, messageNew"
+  }
+});
+
+// src/category/index.ts
+import { initContract as initContract9 } from "@ts-rest/core";
+import z18 from "zod";
+
+// utils.ts
+import { z as z15 } from "zod";
+var paginationSchema = z15.object({
+  page: z15.number().default(1),
+  pageSize: z15.number().default(10),
+  total: z15.number(),
+  lastPage: z15.number().optional().nullable()
+});
+var withPagination = (dataSchema) => {
+  return paginationSchema.extend({
+    data: z15.array(dataSchema)
+  });
+};
+
+// src/category/schema.ts
+import { z as z16 } from "zod";
+var categoryLevelSchema = z16.union([
+  z16.literal(1),
+  z16.literal(2),
+  z16.literal(3)
+]);
+var categorySchema = z16.object({
+  id: z16.string(),
+  value: z16.string(),
+  level: categoryLevelSchema,
+  parentId: z16.string().nullable(),
+  childCategoryList: z16.array(
+    z16.object({
+      id: z16.string(),
+      value: z16.string(),
+      level: categoryLevelSchema,
+      parentId: z16.string().nullable(),
+      childCategoryList: z16.array(
+        z16.object({
+          id: z16.string(),
+          value: z16.string(),
+          level: categoryLevelSchema,
+          parentId: z16.string().nullable(),
+          childCategoryList: z16.array(z16.any())
+          // This is an empty array.
+        })
+      )
+    })
+  )
+});
+
+// src/category/validation.ts
+import { z as z17 } from "zod";
+var createCategorySchema = z17.object({
+  value: z17.string(),
+  level: categoryLevelSchema,
+  parentId: z17.string().nullable()
+});
+var updateCategorySchema = z17.object({ value: z17.string() });
+var createCategoryLevelSchema = z17.object({
+  name: z17.string(),
+  level: categoryLevelSchema
+});
+var updateCategoryLevelSchema = z17.object({
+  id: z17.string(),
+  name: z17.string(),
+  level: categoryLevelSchema
+});
+
+// src/category/index.ts
+var categoryContract = initContract9().router(
+  {
+    createCategory: {
+      method: "POST",
+      path: "",
+      headers: DefaultHeaderSchema,
+      body: createCategorySchema,
+      responses: {
+        201: DefaultSuccessResponseSchema.extend({
+          category: categorySchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    getCategories: {
+      method: "GET",
+      path: "",
+      query: z18.object({
+        page: z18.coerce.number().optional(),
+        pageSize: z18.coerce.number().optional()
+      }).optional(),
+      headers: DefaultHeaderSchema,
+      responses: {
+        200: withPagination(categorySchema),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    updateCategory: {
+      method: "PATCH",
+      path: "/:id",
+      pathParams: z18.object({ id: z18.string() }),
+      headers: DefaultHeaderSchema.extend({
+        category: categorySchema
+      }),
+      body: updateCategorySchema,
+      responses: {
+        200: DefaultSuccessResponseSchema,
+        500: DefaultErrorResponseSchema
+      }
+    },
+    deleteCategory: {
+      method: "DELETE",
+      path: "/:id",
+      pathParams: z18.object({ id: z18.string() }),
+      headers: DefaultHeaderSchema,
+      body: z18.any().optional(),
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({ message: z18.string() }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    createCategoryLevel: {
+      method: "POST",
+      path: "/level",
+      headers: DefaultHeaderSchema,
+      body: createCategoryLevelSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          categoryLevel: categoryLevelSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    },
+    updateCategoryLevel: {
+      method: "PATCH",
+      path: "/level/:id",
+      pathParams: z18.object({ id: z18.string() }),
+      headers: DefaultHeaderSchema,
+      body: updateCategoryLevelSchema,
+      responses: {
+        200: DefaultSuccessResponseSchema.extend({
+          categoryLevel: categoryLevelSchema
+        }),
+        500: DefaultErrorResponseSchema
+      }
+    }
+  },
+  {
+    pathPrefix: "categories"
+  }
+);
+
+// src/contract.ts
+var apiContract = initContract10().router({
+  auth: authContract,
+  mail: mailContract,
+  cxLog: cxLogContract,
+  emailEngineWebhooks: emailEngineWebhooksEventsContract,
+  category: categoryContract
+});
+export {
+  apiContract,
+  categoryContract
+};
+//# sourceMappingURL=index.mjs.map