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

package/contracts/secondaries/index.ts

@@ -0,0 +1,23 @@
+import { initContract } from '@ts-rest/core';
+import { accountsContract } from './accounts';
+import { secondaryCustomersContract } from './secondary-customers';
+import { secondaryIssuersContract } from './secondary-issuers';
+import { secondaryOrdersContract } from './secondary-orders';
+import { secondarySecuritiesContract } from './secondary-securities';
+import { secondaryTradesContract } from './secondary-trades';
+const c = initContract();
+
+// API KEY AUTH
+export const secondariesContract = c.router(
+  {
+    accounts: accountsContract,
+    secondaryCustomer: secondaryCustomersContract,
+    secondaryIssuers: secondaryIssuersContract,
+    secondaryOrders: secondaryOrdersContract,
+    secondarySecurities: secondarySecuritiesContract,
+    secondaryTrades: secondaryTradesContract,
+  },
+  {
+    pathPrefix: '/secondaries/api/v1/',
+  },
+);

package/contracts/secondaries/secondary-customers/index.ts

@@ -0,0 +1,55 @@
+import { initContract } from '@ts-rest/core';
+import {
+  IPaginatedSecondaryCustomers,
+  SecondaryCustomerFiltersZod,
+  secondaryCustomerIdSchema,
+  SecondaryCustomer,
+} from '../../../common/types/secondary-customer.types';
+import {
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+  PaginationOptionsZod,
+} from '../../../common/types';
+import { z } from 'zod';
+
+const c = initContract();
+
+export const secondaryCustomersContract = c.router(
+  {
+    getCustomers: {
+      summary: 'Get Customers',
+      method: 'GET',
+      path: '',
+      metadata: {
+        auth: true,
+      },
+      query: PaginationOptionsZod.merge(SecondaryCustomerFiltersZod),
+      responses: {
+        200: IPaginatedSecondaryCustomers,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+      },
+    },
+    getCustomer: {
+      summary: 'Get Customer',
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: secondaryCustomerIdSchema,
+      }),
+      responses: {
+        200: SecondaryCustomer,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'secondary-customers',
+  },
+);

package/contracts/secondaries/secondary-issuers/index.ts

@@ -0,0 +1,94 @@
+import { initContract } from '@ts-rest/core';
+import {
+  BadRequestError,
+  InternalError,
+  ForbiddenError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types/error-responses.types';
+import { z } from 'zod';
+import { PaginationOptionsZod } from '../../../common/types/common.types';
+import {
+  CreateSecondaryIssuer,
+  IPaginatedSecondaryIssuers,
+  secondaryIssuerIdSchema,
+  SecondaryIssuerZod,
+  UpdateSecondaryIssuer,
+} from '../../../common/types/secondary-issuer.types';
+const c = initContract();
+
+export const secondaryIssuersContract = c.router(
+  {
+    getSecondaryIssuers: {
+      method: 'GET',
+      summary: 'Get all secondary issuers',
+      path: '',
+      query: PaginationOptionsZod,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: IPaginatedSecondaryIssuers,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getSecondaryIssuer: {
+      method: 'GET',
+      summary: 'Get a secondary issuer by id',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: secondaryIssuerIdSchema,
+      }),
+      responses: {
+        200: SecondaryIssuerZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSecondaryIssuer: {
+      method: 'POST',
+      summary: 'Create a secondary issuer',
+      path: '',
+      body: CreateSecondaryIssuer,
+      metadata: {
+        auth: true,
+      },
+      responses: {
+        200: SecondaryIssuerZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateSecondaryIssuer: {
+      method: 'PUT',
+      summary: 'Update a secondary issuer',
+      path: '/:id',
+      body: UpdateSecondaryIssuer,
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: secondaryIssuerIdSchema,
+      }),
+      responses: {
+        200: SecondaryIssuerZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'secondary-issuers',
+  },
+);

package/contracts/secondaries/secondary-orders/index.ts

@@ -0,0 +1,56 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import { PaginationOptionsZod } from '../../../common/types/common.types';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types/error-responses.types';
+import {
+  IPaginatedSecondaryOrders,
+  SecondaryOrder,
+  secondaryOrderIdSchema,
+} from '../../../common/types/secondary-order.types';
+const c = initContract();
+
+export const secondaryOrdersContract = c.router(
+  {
+    getSecondaryOrders: {
+      method: 'GET',
+      path: '',
+      query: PaginationOptionsZod,
+      metadata: {
+        auth: true,
+      },
+      summary: 'Get all secondary orders',
+      responses: {
+        200: IPaginatedSecondaryOrders,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getSecondaryOrder: {
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: secondaryOrderIdSchema,
+      }),
+      summary: 'Get a secondary order by id',
+      responses: {
+        200: SecondaryOrder,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'secondary-orders',
+  },
+);

package/contracts/secondaries/secondary-securities/index.ts

@@ -0,0 +1,95 @@
+import { initContract } from '@ts-rest/core';
+import { PaginationOptionsZod } from '../../../common/types/common.types';
+import { z } from 'zod';
+import {
+  BadRequestError,
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+} from '../../../common/types/error-responses.types';
+import { UnauthorizedError } from '../../../common/types/error-responses.types';
+import {
+  CreateSecondarySecurity,
+  IPaginatedSecondarySecurities,
+  secondarySecurityIdSchema,
+  SecondarySecurityZod,
+  UpdateSecondarySecurity,
+} from '../../../common/types/secondary-security.types';
+const c = initContract();
+
+export const secondarySecuritiesContract = c.router(
+  {
+    getSecondarySecurities: {
+      method: 'GET',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      summary: 'Get all secondary securities',
+      query: PaginationOptionsZod,
+      responses: {
+        200: IPaginatedSecondarySecurities,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getSecondarySecurity: {
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: secondarySecurityIdSchema,
+      }),
+      summary: 'Get a secondary security by id',
+      responses: {
+        200: SecondarySecurityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+    createSecondarySecurity: {
+      method: 'POST',
+      path: '/',
+      metadata: {
+        auth: true,
+      },
+      summary: 'Create a secondary security',
+      body: CreateSecondarySecurity,
+      responses: {
+        201: SecondarySecurityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+    updateSecondarySecurity: {
+      method: 'PUT',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      summary: 'Update a secondary security',
+      pathParams: z.object({
+        id: secondarySecurityIdSchema,
+      }),
+      body: UpdateSecondarySecurity,
+      responses: {
+        200: SecondarySecurityZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        400: BadRequestError,
+        500: InternalError,
+      },
+    },
+  },
+
+  {
+    pathPrefix: 'secondary-securities',
+  },
+);

package/contracts/secondaries/secondary-trades/index.ts

@@ -0,0 +1,56 @@
+import { initContract } from '@ts-rest/core';
+import { z } from 'zod';
+import { PaginationOptionsZod } from '../../../common/types/common.types';
+import {
+  ForbiddenError,
+  InternalError,
+  NotFoundError,
+  UnauthorizedError,
+} from '../../../common/types/error-responses.types';
+import {
+  IPaginatedSecondaryTrades,
+  secondaryTradeIdSchema,
+  SecondaryTradeZod,
+} from '../../../common/types/secondary-trade.types';
+const c = initContract();
+
+export const secondaryTradesContract = c.router(
+  {
+    getSecondaryTrades: {
+      method: 'GET',
+      path: '',
+      query: PaginationOptionsZod,
+      metadata: {
+        auth: true,
+      },
+      summary: 'Get all secondary trades',
+      responses: {
+        200: IPaginatedSecondaryTrades,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        500: InternalError,
+      },
+    },
+    getSecondaryTrade: {
+      method: 'GET',
+      path: '/:id',
+      metadata: {
+        auth: true,
+      },
+      pathParams: z.object({
+        id: secondaryTradeIdSchema,
+      }),
+      summary: 'Get a secondary trade by id',
+      responses: {
+        200: SecondaryTradeZod,
+        401: UnauthorizedError,
+        403: ForbiddenError,
+        404: NotFoundError,
+        500: InternalError,
+      },
+    },
+  },
+  {
+    pathPrefix: 'secondary-trades',
+  },
+);

package/package.json

@@ -0,0 +1,77 @@
+{
+  "name": "@dalmore/api-contracts",
+  "version": "0.0.0-dev.2dc8e92",
+  "description": "Type-safe API contracts for Dalmore Client Portal",
+  "main": "./contracts/index.ts",
+  "types": "./contracts/index.ts",
+  "exports": {
+    ".": {
+      "types": "./contracts/index.ts",
+      "default": "./contracts/index.ts"
+    },
+    "./compliance": {
+      "types": "./contracts/compliance/index.ts",
+      "default": "./contracts/compliance/index.ts"
+    },
+    "./investors": {
+      "types": "./contracts/investors/index.ts",
+      "default": "./contracts/investors/index.ts"
+    },
+    "./issuers": {
+      "types": "./contracts/issuers/index.ts",
+      "default": "./contracts/issuers/index.ts"
+    },
+    "./clients": {
+      "types": "./contracts/clients/index.ts",
+      "default": "./contracts/clients/index.ts"
+    },
+    "./secondaries": {
+      "types": "./contracts/secondaries/index.ts",
+      "default": "./contracts/secondaries/index.ts"
+    },
+    "./compliance-apikey": {
+      "types": "./contracts/compliance-apikey/index.ts",
+      "default": "./contracts/compliance-apikey/index.ts"
+    },
+    "./types": {
+      "types": "./common/types/index.ts",
+      "default": "./common/types/index.ts"
+    },
+    "./types/*": {
+      "types": "./common/types/*.ts",
+      "default": "./common/types/*.ts"
+    }
+  },
+  "files": [
+    "contracts",
+    "common"
+  ],
+  "keywords": [
+    "dalmore",
+    "api",
+    "contracts",
+    "ts-rest",
+    "typescript"
+  ],
+  "author": "Dalmore Group",
+  "license": "UNLICENSED",
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/OfficialDalmoreGroup/dalmore-client-portal-api.git"
+  },
+  "peerDependencies": {
+    "@anatine/zod-openapi": "^1.14.2",
+    "@ts-rest/core": "^3.52.1",
+    "typeid-js": "^1.2.0",
+    "zod": "^3.24.4"
+  },
+  "devDependencies": {
+    "typescript": "^5.8.3"
+  },
+  "engines": {
+    "node": ">=24.0.0 <25.0.0"
+  }
+}