@dalmore/api-contracts 0.0.0-dev.d30d175 → 0.0.0-dev.ff07a57

package/common/types/file.types.ts

@@ -17,7 +17,7 @@ import { KybZod } from './kyb.types';
 import { IIndividualZod, individualIdSchema } from './individuals.types';
 import { LegalEntityZod } from './legal-entity.types';
 import { IInvestorAccount } from './investor-account.types';
-import { TradeZod } from './trade.types';
+import { tradeIdSchema, TradeZod } from './trade.types';
 
 extendZodWithOpenApi(z);
 
@@ -168,13 +168,13 @@ export type PostFileQueryParams = z.infer<typeof PostFileQueryParams>;
 
 /**
  * CLIENT portal specific schema for file uploads
- * Only allows INDIVIDUALS as target for file uploads
+ * Only allows INDIVIDUALS and TRADES as target for file uploads
  */
 export const ClientPostFileQueryParams = z.object({
   name: z.string().min(1).max(100).openapi({ example: 'file_name' }),
   category: z.string().max(50).openapi({ example: 'application' }),
   label: FileLabelsEnum.openapi({ example: FileLabels.OTHER }),
-  targetId: individualIdSchema.openapi({
+  targetId: z.union([individualIdSchema, tradeIdSchema]).openapi({
     example: 'individual_01kcrsny60fb9rjc8bbqc3b80c',
   }),
   metadata: metadataSchema.nullable().optional(),

package/common/types/index.ts

@@ -42,6 +42,7 @@ export * from './domain-filter.types';
 export * from './aic.types';
 export * from './default-theme-config.types';
 export * from './offering-reports.types';
+export * from './payment-methods.types';
 
 export enum Versions {
   V1 = 'v1',

package/common/types/issuer-offering.types.ts

@@ -13,12 +13,7 @@ import {
 } from './common.types';
 import { IBaseEntity } from './entity.types';
 import { IIssuer, issuerIdSchema } from './issuer.types';
-import {
-  IAsset,
-  postAssetRefinement,
-  AssetTemplateType,
-  assetIdSchema,
-} from './asset.types';
+import { IAsset, postAssetRefinement, AssetTemplateType } from './asset.types';
 import { fileIdSchema, FileZod } from './file.types';
 import { accountIdSchema } from './account.types';
 
@@ -258,7 +253,6 @@ export const PatchIssuerOffering = z.object({
   managedBy: z.nativeEnum(ManagedByType).optional(),
   showTotalRaised: z.boolean().optional(),
   issuerId: issuerIdSchema.optional(),
-  assetId: assetIdSchema,
   assetName: z.string().min(2).max(50).optional().openapi({ example: 'Z' }),
   assetType: z
     .nativeEnum(AssetType)

package/common/types/issuer-payment-method.types.ts

@@ -222,10 +222,51 @@ export type IPaginatedIssuerPaymentMethod = z.infer<
   typeof IPaginatedIssuerPaymentMethod
 >;
 
+const issuerPaymentMethodsInclude = z.enum(['issuer', 'integration']);
+
+/**
+ * @description Query parameters for including related entities
+ * @example in contract use as -> query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(IssuerPaymentMethodsIncludeQuery)
+ */
+export const IssuerPaymentMethodsIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          issuerPaymentMethodsInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${issuerPaymentMethodsInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${issuerPaymentMethodsInclude.options.join(',')}`,
+    }),
+});
+export type IssuerPaymentMethodsIncludeQuery = z.infer<
+  typeof IssuerPaymentMethodsIncludeQuery
+>;
+
 export const GetIssuerPaymentMethodZod = z.object({
   issuerId: issuerIdSchema.openapi({
     example: 'issuer_01jdq2crwke8xskjd840cj79pw',
   }),
+  enabled: z
+    .string()
+    .optional()
+    .refine((v) => !v || v === 'true' || v === 'false', {
+      message: 'enabled must be a boolean string',
+    })
+    .transform((v) => {
+      if (!v) return undefined;
+      return v === 'true';
+    })
+    .openapi({
+      example: 'true',
+    }),
 });
 export type GetIssuerPaymentMethodZod = z.infer<
   typeof GetIssuerPaymentMethodZod

package/common/types/offering.types.ts

@@ -26,11 +26,7 @@ import {
   InvestorsOfferingsIncludeQuery,
 } from './investors-offering.types';
 import { OfferingStatus } from './issuer-offering.types';
-import {
-  assetIdSchema,
-  postAssetRefinement,
-  AssetTemplateType,
-} from './asset.types';
+import { postAssetRefinement, AssetTemplateType } from './asset.types';
 
 export enum OfferingFeeType {
   FIXED = 'FIXED',
@@ -184,7 +180,6 @@ export const PatchOfferingBase = z.object({
 });
 export const PatchOffering = PatchOfferingBase.merge(
   z.object({
-    assetId: assetIdSchema,
     assetName: z
       .string()
       .min(2)

package/contracts/clients/cart/index.ts

@@ -0,0 +1,60 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  BadRequestError,
+  InternalError,
+  TradeZod,
+  userIdSchema,
+  tradeIdSchema,
+} from '../../../common/types';
+import { PatchCartBody } from '../../../common/types/cart.types';
+
+const c = initContract();
+
+export const cartContract = c.router(
+  {
+    getTradeCart: {
+      summary: 'Get carts (Trade.status = CART)',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: TradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    patchCart: {
+      summary: 'Patch a cart',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: tradeIdSchema,
+      }),
+      body: PatchCartBody,
+      responses: {
+        200: TradeZod,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'carts',
+  },
+);

package/contracts/clients/index.ts

@@ -3,6 +3,7 @@ import { accountsContract } from './accounts';
 import { apiKeysContract } from './api-keys';
 import { clientApiKeyLogsContract } from './api-key-logs';
 import { assetsContract } from './assets';
+import { cartContract } from './cart';
 import { filesContract } from './files';
 import { individualsContract } from './individuals';
 import { investorAccountsContract } from './investor-accounts';
@@ -15,6 +16,9 @@ import { secureRequestContract } from './secure-requests';
 import { aicContract } from './aic';
 import { authContract } from './auth';
 import { sitesContract } from './sites';
+import { paymentMethodsContract } from './payment-methods';
+import { issuerPaymentMethodsContract } from './issuer-payment-methods';
+import { tradeLineItemsContract } from './trade-line-items';
 
 const c = initContract();
 
@@ -27,15 +31,19 @@ export const clientsContract = c.router(
     apiKeys: apiKeysContract,
     apiKeyLogs: clientApiKeyLogsContract,
     assets: assetsContract,
+    cart: cartContract,
     files: filesContract,
     filesPublic: filesPublicContract,
     individuals: individualsContract,
     investorAccounts: investorAccountsContract,
+    issuerPaymentMethods: issuerPaymentMethodsContract,
     issuers: issuersContract,
     legalEntities: legalEntityContract,
     offerings: offeringsContract,
+    paymentMethods: paymentMethodsContract,
     secureRequests: secureRequestContract,
     sites: sitesContract,
+    tradeLineItems: tradeLineItemsContract,
     trades: tradesContract,
   },
   {

package/contracts/clients/issuer-payment-methods/index.ts

@@ -0,0 +1,39 @@
+import { initContract } from '@ts-rest/core';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  GetIssuerPaymentMethodZod,
+  IPaginatedIssuerPaymentMethod,
+  IssuerPaymentMethodsIncludeQuery,
+  PaginationOptionsZod,
+} from '../../../common/types';
+
+const c = initContract();
+
+export const issuerPaymentMethodsContract = c.router(
+  {
+    getIssuerPaymentMethods: {
+      summary: 'Get issuer payment methods',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(GetIssuerPaymentMethodZod).merge(
+        IssuerPaymentMethodsIncludeQuery,
+      ),
+      responses: {
+        200: IPaginatedIssuerPaymentMethod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'issuer-payment-methods',
+  },
+);

package/contracts/clients/payment-methods/index.ts

@@ -0,0 +1,85 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  UnauthorizedError,
+  ForbiddenError,
+  NotFoundError,
+  userIdSchema,
+  BadRequestError,
+  InternalError,
+} from '../../../common/types';
+import {
+  PaymentMethodResponseArray,
+  PaymentMethodResponse,
+  PostPaymentMethod,
+  PostSetupIntentBody,
+  SetupIntentResponse,
+} from '../../../common/types/payment-methods.types';
+
+const c = initContract();
+
+export const paymentMethodsContract = c.router(
+  {
+    getPaymentMethods: {
+      summary: 'Get payment methods for a user',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      responses: {
+        200: PaymentMethodResponseArray,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createPaymentMethod: {
+      summary: 'Create payment method for a user',
+      method: 'POST',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostPaymentMethod,
+      responses: {
+        201: PaymentMethodResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSetupIntent: {
+      summary: 'Create payment method setup intent for a user',
+      method: 'POST',
+      path: '/intent',
+      metadata: {
+        auth: true,
+      },
+      query: z.object({
+        userId: userIdSchema,
+      }),
+      body: PostSetupIntentBody,
+      responses: {
+        201: SetupIntentResponse,
+        400: BadRequestError,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'payment-methods',
+  },
+);

package/contracts/clients/trade-line-items/index.ts

@@ -0,0 +1,66 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+  userIdSchema,
+} from '../../../common/types';
+import {
+  PostTradeLineItem,
+  TradeLineItemParams,
+  TradeLineItemQuery,
+  TradeLineItemResponse,
+  TradeLineItemUpdate,
+} from '../../../common/types/trade-line-item.type';
+
+const c = initContract();
+
+export const tradeLineItemsContract = c.router(
+  {
+    postTradeLineItem: {
+      summary: 'Create Trade Line Item',
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      body: PostTradeLineItem,
+      query: TradeLineItemQuery.merge(
+        z.object({
+          userId: userIdSchema,
+        }),
+      ),
+      responses: {
+        201: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateTradeLineItem: {
+      summary: 'Update Trade Line Item - Can delete if you pass quantity = 0',
+      method: 'PATCH',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: TradeLineItemParams,
+      body: TradeLineItemUpdate,
+      responses: {
+        200: TradeLineItemResponse,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+        400: BadRequestError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'trade-line-items',
+  },
+);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dalmore/api-contracts",
-  "version": "0.0.0-dev.d30d175",
+  "version": "0.0.0-dev.ff07a57",
   "description": "Type-safe API contracts for Dalmore Client Portal",
   "main": "./contracts/index.ts",
   "types": "./contracts/index.ts",