@dalmore/api-contracts 0.0.0-dev.2dc8e92 → 0.0.0-dev.4bb6b7a

package/contracts/secondaries/index.ts

@@ -1,23 +0,0 @@
-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

@@ -1,55 +0,0 @@
-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

@@ -1,94 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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

@@ -1,95 +0,0 @@
-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

@@ -1,56 +0,0 @@
-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',
-  },
-);