@dalmore/api-contracts 0.0.0-dev.2dc8e92

package/contracts/issuers/trades/index.ts

@@ -0,0 +1,132 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedTrade,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  TradeZod,
+  TradesIncludeQuery,
+  tradeIdSchema,
+  IssuersTradeFiltersZod,
+  reviewTrades,
+  CancelTradeResponse,
+  InternalError,
+  CancelTradeZod,
+  TradeDisbursementsZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const issuerTradesContract = c.router(
+  {
+    exportTrades: {
+      summary: 'Export trades into a csv file',
+      method: 'GET',
+      path: '/export',
+      metadata: {
+        auth: true,
+      },
+      query: IssuersTradeFiltersZod,
+      responses: {
+        200: z.unknown(),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+
+    getTrade: {
+      summary: 'Get trade by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z
+        .object({})
+        .merge(IssuersTradeFiltersZod)
+        .merge(TradesIncludeQuery),
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getTrades: {
+      summary: 'Get trades',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuersTradeFiltersZod).merge(
+        TradesIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedTrade,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getTradeDisbursements: {
+      summary: 'Get trade disbursements',
+      method: 'GET',
+      path: '/:id/disbursements',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      responses: {
+        200: TradeDisbursementsZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    reviewTrade: {
+      summary: 'Review Trades',
+      method: 'PATCH',
+      path: '/review',
+      metadata: {
+        auth: true,
+      },
+      body: reviewTrades,
+      responses: {
+        201: z.object({ success: z.boolean() }),
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    cancelTrade: {
+      summary: 'Cancel Trade',
+      method: 'PUT',
+      path: '/cancel/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: CancelTradeZod,
+      responses: {
+        201: CancelTradeResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trades',
+  },
+);

package/contracts/issuers/transactions/index.ts

@@ -0,0 +1,158 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  PostTransactionZod,
+  transactionIdSchema,
+  TransactionZod,
+  CreateRefundZod,
+  UpdateRefundZod,
+  RefundTransactionZod,
+  GetRefundResponseZod,
+  GetTransactionRefundsResponseZod,
+  refundTransactionIdSchema,
+} from '../../../common/types/transaction.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const issuerTransactionsContract = c.router(
+  {
+    markTransactionAsReceived: {
+      summary: 'Mark a transaction as received',
+      method: 'PATCH',
+      path: '/:id/received',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: transactionIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        201: TransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    postTransaction: {
+      summary: 'Create a transaction',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      body: PostTransactionZod,
+      responses: {
+        201: TransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    voidTransaction: {
+      summary: 'Void a transaction',
+      method: 'PATCH',
+      path: '/:id/void',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: transactionIdSchema,
+      }),
+      body: z.object({}),
+      responses: {
+        201: TransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getTransactionRefunds: {
+      summary: 'Get All Refunds for Transaction',
+      description:
+        'Retrieves all refunds for a transaction with balance summary',
+      method: 'GET',
+      path: '/:id/refunds',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: transactionIdSchema,
+      }),
+      responses: {
+        200: GetTransactionRefundsResponseZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createRefund: {
+      summary: 'Create Refund Transaction',
+      description: 'Creates a refund for a settled CHECK or WIRE transaction',
+      method: 'POST',
+      path: '/refund',
+      metadata: {
+        auth: true,
+      },
+      body: CreateRefundZod,
+      responses: {
+        201: RefundTransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getRefund: {
+      summary: 'Get Refund Transaction',
+      description:
+        'Retrieves refund details with calculated transaction balance',
+      method: 'GET',
+      path: '/refund/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: refundTransactionIdSchema,
+      }),
+      responses: {
+        200: GetRefundResponseZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateRefund: {
+      summary: 'Update Refund Transaction',
+      description: 'Updates refund status (PENDING→SETTLED/CANCELLED) or notes',
+      method: 'PATCH',
+      path: '/refund/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: refundTransactionIdSchema,
+      }),
+      body: UpdateRefundZod,
+      responses: {
+        200: RefundTransactionZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'transactions',
+  },
+);

package/contracts/issuers/user-manuals/index.ts

@@ -0,0 +1,62 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  IPaginatedUserManualCategory,
+  IUserManualCategory,
+  userManualCategoriesIncludeQuery,
+  userManualCategorySchema,
+  GetLimitedUserManualCategoryZod,
+  UserManualsPaginationOptionsZod,
+} from '../../../common/types/user-manual.types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const userManualsContract = c.router(
+  {
+    getUserManualCategories: {
+      summary: 'Get user manual Categories',
+      method: 'GET',
+      path: '/categories',
+      metadata: {
+        auth: true,
+      },
+      query: UserManualsPaginationOptionsZod.merge(
+        userManualCategoriesIncludeQuery,
+      ).merge(GetLimitedUserManualCategoryZod),
+      responses: {
+        200: IPaginatedUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getUserManualCategory: {
+      summary: 'Get user manual category',
+      method: 'GET',
+      path: '/categories/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: userManualCategorySchema,
+      }),
+      query: z.object({}).merge(userManualCategoriesIncludeQuery),
+      responses: {
+        200: IUserManualCategory,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'user-manuals',
+  },
+);

package/contracts/issuers/user-settings/index.ts

@@ -0,0 +1,170 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types';
+import {
+  sendEmailVerificationBody,
+  sendEmailVerificationResponse,
+  sendVerificationCodeBody,
+  sendVerificationCodeResponse,
+  setupPhoneNumberBody,
+  setupPhoneNumberResponse,
+  setupTwoFactorResponse,
+  userSettingsZod,
+  validPhoneNumberBody,
+  validPhoneNumberResponse,
+  verifyEmailBody,
+  verifyEmailResponse,
+  verifyPhoneNumberBody,
+  verifyPhoneNumberResponse,
+  verifyTwoFactorBody,
+  verifyTwoFactorResponse,
+} from '../../../common/types/user-setting.types';
+
+const c = initContract();
+
+export const userSettingsContract = c.router(
+  {
+    getUserSettings: {
+      summary: 'Get current user settings',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: userSettingsZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    validPhoneNumber: {
+      summary: 'Validate phone number',
+      method: 'POST',
+      path: '/valid-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: validPhoneNumberBody,
+      responses: {
+        200: validPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setupPhoneNumber: {
+      summary: 'Setup phone number',
+      method: 'POST',
+      path: '/setup-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: setupPhoneNumberBody,
+      responses: {
+        200: setupPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    verifyPhoneNumber: {
+      summary: 'Verify phone number',
+      method: 'POST',
+      path: '/verify-phone-number',
+      metadata: {
+        auth: true,
+      },
+      body: verifyPhoneNumberBody,
+      responses: {
+        200: verifyPhoneNumberResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    sendVerificationCode: {
+      summary: 'Send verification code',
+      method: 'POST',
+      path: '/send-verification-code',
+      metadata: {
+        auth: true,
+      },
+      body: sendVerificationCodeBody,
+      responses: {
+        200: sendVerificationCodeResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    setupTwoFactorAuthenticator: {
+      summary: 'Setup 2FA',
+      method: 'GET',
+      path: '/setup-authenticator',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        201: setupTwoFactorResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    verifyTwoFactorAuthenticator: {
+      summary: 'Verify 2FA',
+      method: 'POST',
+      path: '/verify-authenticator',
+      body: verifyTwoFactorBody,
+      responses: {
+        201: verifyTwoFactorResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+    sendEmailVerification: {
+      summary: 'Send email verification code',
+      method: 'POST',
+      path: '/send-email-verification',
+      metadata: {
+        auth: true,
+      },
+      body: sendEmailVerificationBody,
+      responses: {
+        200: sendEmailVerificationResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        429: BadRequestError,
+        500: InternalError,
+      },
+    },
+    verifyEmail: {
+      summary: 'Verify email with code',
+      method: 'POST',
+      path: '/verify-email',
+      metadata: {
+        auth: true,
+      },
+      body: verifyEmailBody,
+      responses: {
+        200: verifyEmailResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'user-settings',
+  },
+);

package/contracts/issuers/users/index.ts

@@ -0,0 +1,126 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  ForbiddenError,
+  GetMeResponse,
+  InternalError,
+  IPaginatedUser,
+  IssuersActiveStatusUpdateZod,
+  IssuersUsersFiltersZod,
+  IssuerUsersStatusUpdateResponse,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  UpdateUserRoleZod,
+  userIdSchema,
+  UserMeUpdateZod,
+  UsersIncludeQuery,
+  UserWithoutPasswordZod,
+  UserZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const issuerUsersContract = c.router(
+  {
+    getUsers: {
+      summary: 'Get users',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(IssuersUsersFiltersZod).merge(
+        UsersIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedUser,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    me: {
+      summary: 'Get current user',
+      method: 'GET',
+      path: '/me',
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: GetMeResponse,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    getUser: {
+      summary: 'Get user by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(UsersIncludeQuery),
+      pathParams: z.object({
+        id: z.string(),
+      }),
+      responses: {
+        200: UserZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+      },
+    },
+    updateMe: {
+      summary: 'Update current user',
+      method: 'PATCH',
+      path: '/me',
+      metadata: {
+        auth: true,
+      },
+      body: UserMeUpdateZod,
+      responses: {
+        201: UserWithoutPasswordZod,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateActiveStatus: {
+      summary: 'Update current user',
+      method: 'PATCH',
+      path: '/active/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({ id: userIdSchema }),
+      body: IssuersActiveStatusUpdateZod,
+      responses: {
+        201: IssuerUsersStatusUpdateResponse,
+        401: UnauthorizedError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    updateRole: {
+      summary: 'Update user role',
+      method: 'PATCH',
+      path: '/role',
+      metadata: {
+        auth: true,
+      },
+      body: UpdateUserRoleZod,
+      responses: {
+        201: UserWithoutPasswordZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'users',
+  },
+);

package/contracts/secondaries/accounts/index.ts

@@ -0,0 +1,58 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  IPaginatedAccount,
+  NotFoundError,
+  PaginationOptionsZod,
+  UnauthorizedError,
+  AccountFiltersZod,
+  AccountsIncludeQuery,
+  AccountZod,
+  accountIdSchema,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const accountsContract = c.router(
+  {
+    getAccount: {
+      summary: 'Get account by id',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({}).merge(AccountsIncludeQuery),
+      pathParams: z.object({
+        id: accountIdSchema,
+      }),
+      responses: {
+        200: AccountZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+    getAccounts: {
+      summary: 'Get accounts',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query:
+        PaginationOptionsZod.merge(AccountFiltersZod).merge(
+          AccountsIncludeQuery,
+        ),
+      responses: {
+        200: IPaginatedAccount,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'accounts',
+  },
+);