@dalmore/api-contracts 1.0.7 → 1.0.9

package/README.md

@@ -2,6 +2,8 @@
 
 Type-safe API contracts for Dalmore Client Portal, powered by [ts-rest](https://ts-rest.com/).
 
+This package provides **full end-to-end type inference** by shipping TypeScript source files alongside compiled JavaScript.
+
 ## Installation
 
 ```bash
@@ -27,13 +29,27 @@ const client = initClient(clientsContract, {
   },
 });
 
-// Fully typed API calls
+// Fully typed API calls with complete autocomplete
 const { status, body } = await client.accounts.getAccounts();
 
-// Access nested endpoints
+// Access nested endpoints with full type inference
 const trade = await client.trades.getTrade({ params: { id: 'trade_123' } });
 ```
 
+## TypeScript Configuration
+
+For optimal type inference, ensure your `tsconfig.json` includes:
+
+```json
+{
+  "compilerOptions": {
+    "skipLibCheck": true, // Recommended for faster compilation
+    "moduleResolution": "node",
+    "esModuleInterop": true
+  }
+}
+```
+
 ## Available Endpoints
 
 The `clientsContract` includes:

package/index.mjs

@@ -5,10 +5,6 @@ import { z } from 'zod';
 import { HttpStatus } from '@nestjs/common';
 import parsePhoneNumberFromString from 'libphonenumber-js';
 import { ok, err } from 'neverthrow';
-import 'bcrypt';
-import 'crypto';
-import 'currency-codes';
-import 'typeorm';
 
 // src/contracts/clients/index.ts
 extendZodWithOpenApi(z);
@@ -985,10 +981,10 @@ var LogContextZod = z.object({
   "internal-error": {
     status: HttpStatus.INTERNAL_SERVER_ERROR}
 });
-var SortOrder = /* @__PURE__ */ ((SortOrder3) => {
-  SortOrder3["ASC"] = "ASC";
-  SortOrder3["DESC"] = "DESC";
-  return SortOrder3;
+var SortOrder = /* @__PURE__ */ ((SortOrder2) => {
+  SortOrder2["ASC"] = "ASC";
+  SortOrder2["DESC"] = "DESC";
+  return SortOrder2;
 })(SortOrder || {});
 var AMLProvider = /* @__PURE__ */ ((AMLProvider2) => {
   AMLProvider2["COMPLY_ADVANTAGE"] = "ComplyAdvantage";
@@ -1939,9 +1935,9 @@ BLACK_LIST_COUNTRIES.map((c18) => c18.code);
 var PhoneZodSchema = z.string().nullable().transform((phone) => {
   if (phone === null || phone === "") return ok(null);
   let result;
-  for (const code2 of CountryCodes) {
+  for (const code of CountryCodes) {
     if (result && result.isOk()) break;
-    result = normalizePhoneNumber(phone, code2);
+    result = normalizePhoneNumber(phone, code);
   }
   return result;
 }).refine((result) => result.isOk(), { message: "phone is not valid" }).transform((result) => {
@@ -2215,7 +2211,7 @@ var isBase64 = (v) => {
   }
   try {
     return btoa(atob(v)) === v;
-  } catch (err3) {
+  } catch (err2) {
     return false;
   }
 };
@@ -9958,89 +9954,12 @@ var assetsContract = c4.router(
     pathPrefix: "assets"
   }
 );
-var ComplyAdvantageStatus = /* @__PURE__ */ ((ComplyAdvantageStatus2) => {
-  ComplyAdvantageStatus2["FALSE_POSITIVE"] = "false_positive";
-  ComplyAdvantageStatus2["TRUE_POSITIVE"] = "true_positive";
-  ComplyAdvantageStatus2["POTENTIAL_MATCH"] = "potential_match";
-  ComplyAdvantageStatus2["NO_MATCH"] = "no_match";
-  ComplyAdvantageStatus2["UNKNOWN"] = "unknown";
-  ComplyAdvantageStatus2["TRUE_POSITIVE_APPROVE"] = "true_positive_approve";
-  ComplyAdvantageStatus2["TRUE_POSITIVE_REJECT"] = "true_positive_reject";
-  return ComplyAdvantageStatus2;
-})(ComplyAdvantageStatus || {});
-z.object({
-  status: z.enum(["success", "failure"]),
-  content: z.object({
-    data: z.object({
-      match_status: z.nativeEnum(ComplyAdvantageStatus)
-    })
-  }),
-  message: z.string().optional()
-});
-
-// src/common/helpers/index.ts
-var authHeader = {
-  Authorization: "Bearer eyJhbGciOiJIUzI1NiIsInR5cCI6IkpXVCJ9"
-};
-var generateCurlExample = (method, path, options) => {
-  const baseUrl = "https://dalmore-client-portal-api-prod.onrender.com/api/v1";
-  let curl = `curl -X ${method.toUpperCase()} '${baseUrl}${path}`;
-  if (options.query) {
-    const queryString = new URLSearchParams(options.query).toString();
-    curl += `?${queryString}`;
-  }
-  curl += "'";
-  if (options.headers) {
-    Object.entries(options.headers).forEach(([key, value]) => {
-      curl += ` \\
-  --header '${key}: ${value}'`;
-    });
-  }
-  if (options.body) {
-    curl += ` \\
-  --header 'Content-Type: application/json'`;
-    curl += ` \\
-  --data '${JSON.stringify(options.body)}'`;
-  }
-  if (options.formData) {
-    Object.entries(options.formData).forEach(([key, value]) => {
-      curl += ` \\
-  --form '${key}=${value}'`;
-    });
-  }
-  return curl;
-};
-var generateApiDescription = (summary, method, path, options) => {
-  const curlExample = generateCurlExample(method, path, options);
-  return `${summary}
-
-### Example curl request
-
-\`\`\`bash
-${curlExample}
-\`\`\``;
-};
-
-// src/contracts/clients/files/index.ts
 var c5 = initContract();
 var filesContract = c5.router(
   {
     postFile: {
       summary: "Upload a file",
-      description: generateApiDescription(
-        "Upload a file to the system. CLIENT portal only supports uploads to INDIVIDUALS.",
-        "POST",
-        "/files",
-        {
-          query: {
-            name: "test",
-            category: "application",
-            targetId: "individual_01j5tkg6k2fygr0x06fegt27aj"
-          },
-          headers: authHeader,
-          formData: { file: '@"/Users/local/Desktop/test.csv"' }
-        }
-      ),
+      description: "Upload a file to the system. CLIENT portal only supports uploads to INDIVIDUALS.",
       method: "POST",
       path: "",
       query: ClientPostFileQueryParams,
@@ -10656,20 +10575,7 @@ var filesPublicContract = c12.router(
   {
     postFilePublic: {
       summary: "Upload a public file",
-      description: generateApiDescription(
-        "Upload a public file to the system.",
-        "POST",
-        "/files-public",
-        {
-          query: {
-            name: "test",
-            category: "application",
-            targetId: "trade_01j5tkg6k2fygr0x06fegt27aj"
-          },
-          headers: authHeader,
-          formData: { file: '@"/Users/local/Desktop/test.csv"' }
-        }
-      ),
+      description: "Upload a public file to the system.",
       method: "POST",
       path: "",
       query: PostFileQueryParams,
@@ -10967,7 +10873,4 @@ var clientsContract = c17.router(
   }
 );
 
-// src/contracts/clients/package-entry.ts
-var clientsContract2 = clientsContract;
-
-export { clientsContract2 as clientsContract };
+export { clientsContract };

package/package.json

@@ -1,20 +1,20 @@
 {
   "name": "@dalmore/api-contracts",
-  "version": "1.0.7",
+  "version": "1.0.9",
   "description": "Type-safe API contracts for Dalmore Client Portal",
   "type": "module",
   "main": "./index.mjs",
-  "types": "./dist/contracts/clients/index.d.ts",
+  "types": "./src/contracts/clients/index.ts",
   "exports": {
     ".": {
-      "types": "./dist/contracts/clients/index.d.ts",
+      "types": "./src/contracts/clients/index.ts",
       "import": "./index.mjs",
       "default": "./index.mjs"
     }
   },
   "files": [
     "index.mjs",
-    "dist"
+    "src"
   ],
   "keywords": [
     "dalmore",

package/src/common/types/account-contact.types.ts

@@ -0,0 +1,98 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+import { PhoneZodSchema } from './phone.type';
+import {
+  AccountContactType,
+  AccountZod,
+  IPaginationMeta,
+} from './common.types';
+import { IBaseEntity } from './entity.types';
+import { PhoneNumberData } from './sms.types';
+
+extendZodWithOpenApi(z);
+
+export const accountContactIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'account_contact';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid account contact ID format. Must be a valid TypeID with "account_contact" prefix.',
+  },
+);
+
+export const IAccountContact = IBaseEntity.extend({
+  id: accountContactIdSchema,
+  title: z.string().nullable().openapi({ example: 'Mr' }),
+  firstName: z.string().nullable().openapi({ example: 'John' }),
+  lastName: z.string().nullable().openapi({ example: 'Doe' }),
+  email: z
+    .string()
+    .email()
+    .nullable()
+    .openapi({ example: 'john.doe@example.com' }),
+  phone: PhoneNumberData.nullable().optional().openapi({ example: null }),
+  type: z
+    .nativeEnum(AccountContactType)
+    .openapi({ example: AccountContactType.GENERAL }),
+  accountId: accountIdSchema.openapi({
+    example: 'account_01je6ht4b8fbmttkzh2hs82xqp',
+  }),
+  account: AccountZod.optional().nullable(),
+  referenceLink: z.string().nullable().optional(),
+});
+export type IAccountContact = z.infer<typeof IAccountContact>;
+
+export const PatchAccountContactZod = z.object({
+  title: z
+    .string()
+    .min(1)
+    .max(50)
+    .nullable()
+    .optional()
+    .openapi({ example: 'Mr' }),
+  firstName: z.string().min(1).max(150).openapi({ example: 'John' }),
+  lastName: z.string().min(1).max(150).openapi({ example: 'Doe' }),
+  email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+  phone: PhoneZodSchema.nullable()
+    .optional()
+    .openapi({ example: '+12124567890' }),
+});
+
+export type PatchAccountContactZod = z.infer<typeof PatchAccountContactZod>;
+
+export const CompliancePatchAccountContactZod = PatchAccountContactZod.extend({
+  accountId: accountIdSchema.openapi({
+    example: 'account_01je6ht4b8fbmttkzh2hs82xqp',
+  }),
+  referenceLink: z
+    .string()
+    .url()
+    .max(2048)
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.google.com' }),
+});
+export type CompliancePatchAccountContactZod = z.infer<
+  typeof CompliancePatchAccountContactZod
+>;
+
+export const IPaginatedAccountContact = z.object({
+  items: z.array(IAccountContact),
+  meta: IPaginationMeta,
+});
+export type IPaginatedAccountContact = z.infer<typeof IPaginatedAccountContact>;
+
+export const AccountContactDeleteResponse = z.object({
+  status: z.enum(['pass', 'fail']),
+});
+export type AccountContactDeleteResponse = z.infer<
+  typeof AccountContactDeleteResponse
+>;

package/src/common/types/account-detail.types.ts

@@ -0,0 +1,27 @@
+import { z } from 'zod';
+import { IAsset } from './asset.types';
+import { IIssuer } from './issuer.types';
+import { IOffering } from './offering.types';
+import { IIssuerPaymentMethod } from './issuer-payment-method.types';
+import { SiteZod } from './site.types';
+import { IPage } from './page.types';
+
+export const AccountDetailSummaryZod = z.object({
+  id: z.string(),
+  name: z.string(),
+  issuers: z.array(
+    IIssuer.extend({
+      offerings: z.lazy(() =>
+        z.array(
+          IOffering.extend({
+            assets: z.lazy(() => z.array(IAsset)),
+          }),
+        ),
+      ),
+      paymentMethods: z.lazy(() => z.array(IIssuerPaymentMethod)),
+    }),
+  ),
+  sites: z.lazy(() => z.array(SiteZod)),
+  pages: z.lazy(() => z.array(IPage)),
+});
+export type AccountDetailSummaryZod = z.infer<typeof AccountDetailSummaryZod>;

package/src/common/types/account-integration.types.ts

@@ -0,0 +1,143 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { IBaseEntity } from './entity.types';
+import { accountIdSchema } from './account.types';
+import { IPaginationMeta } from './common.types';
+
+extendZodWithOpenApi(z);
+
+export enum IntegrationType {
+  RAISI = 'RAISI',
+}
+
+export const accountIntegrationIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'account_integration';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid account integration ID format. Must be a valid TypeID with "account_integration" prefix.',
+  },
+);
+
+export const AccountIntegrationZod = IBaseEntity.extend({
+  id: accountIntegrationIdSchema,
+  name: z.string(),
+  integration: z.nativeEnum(IntegrationType),
+  description: z.string().nullable(),
+  partnerId: z.string().nullable(),
+  url: z.string().nullable(),
+  webhook: z.string().nullable(),
+  active: z.boolean(),
+  metadata: z.record(z.string(), z.unknown()).nullable(),
+  accountId: z.lazy(() => accountIdSchema),
+});
+export type AccountIntegrationZod = z.infer<typeof AccountIntegrationZod>;
+
+export const IPaginatedAccountIntegration = z.object({
+  items: z.array(AccountIntegrationZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedAccountIntegration = z.infer<
+  typeof IPaginatedAccountIntegration
+>;
+
+export const PostAccountIntegrationZod = z.object({
+  name: z.string().min(1).max(100).openapi({ example: 'Raisi' }),
+  integration: z
+    .nativeEnum(IntegrationType)
+    .openapi({ example: IntegrationType.RAISI }),
+  description: z
+    .string()
+    .min(1)
+    .max(1000)
+    .nullable()
+    .optional()
+    .openapi({ example: 'Raisi integration' }),
+  partnerId: z
+    .string()
+    .min(1)
+    .max(100)
+    .nullable()
+    .optional()
+    .openapi({ example: '1234567890' }),
+  url: z
+    .string()
+    .url()
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.raisi.com' }),
+  webhook: z
+    .string()
+    .url()
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.raisi.com/webhook' }),
+  active: z.boolean().default(true).openapi({ example: true }),
+  metadata: z
+    .record(z.string(), z.unknown())
+    .nullable()
+    .optional()
+    .openapi({ example: { key: 'value' } }),
+});
+export type PostAccountIntegrationZod = z.infer<
+  typeof PostAccountIntegrationZod
+>;
+
+export const PatchAccountIntegrationZod = z.object({
+  name: z
+    .string()
+    .min(1)
+    .max(100)
+    .nullable()
+    .optional()
+    .openapi({ example: 'Raisi' }),
+  integration: z
+    .nativeEnum(IntegrationType)
+    .optional()
+    .openapi({ example: IntegrationType.RAISI }),
+  description: z
+    .string()
+    .min(1)
+    .max(1000)
+    .nullable()
+    .optional()
+    .openapi({ example: 'Raisi integration' }),
+  partnerId: z.string().min(1).max(100).nullable().optional(),
+  url: z
+    .string()
+    .url()
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.raisi.com' }),
+  webhook: z
+    .string()
+    .url()
+    .nullable()
+    .optional()
+    .openapi({ example: 'https://www.raisi.com/webhook' }),
+  active: z.boolean().nullable().optional(),
+  metadata: z
+    .record(z.string(), z.unknown())
+    .nullable()
+    .optional()
+    .openapi({ example: { key: 'value' } }),
+});
+export type PatchAccountIntegrationZod = z.infer<
+  typeof PatchAccountIntegrationZod
+>;
+
+export const AccountIntegrationFiltersZod = z.object({
+  search: z.string().max(50).optional(),
+  integration: z.nativeEnum(IntegrationType).optional(),
+  active: z.boolean().optional(),
+});
+export type AccountIntegrationFiltersZod = z.infer<
+  typeof AccountIntegrationFiltersZod
+>;

package/src/common/types/account-manager.types.ts

@@ -0,0 +1,124 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { PhoneNumberData } from './sms.types';
+import { userIdSchema, UserZod } from './user.types';
+import { IPaginationMeta } from './common.types';
+import { PhoneZodSchema } from './phone.type';
+
+extendZodWithOpenApi(z);
+export const accountManagerIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'account_manager';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message: `Invalid account manager ID format. Must be a valid TypeID with "account_manager" prefix. Example: account_manager_01j5y5ghx5fg68d663j1fvy2x7`,
+  },
+);
+
+export const accountManagersInclude = z.enum(['accounts', 'user']);
+
+/**
+ * @description Query parameters for including related entities
+ * @xample in contract us as -> query: z.object({}).merge(AccountManagersIncludeQuery),
+ */
+export const AccountManagersIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          accountManagersInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${accountManagersInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${accountManagersInclude.options.join(',')}`,
+    }),
+});
+
+export const IAccountManagerZod = IBaseEntity.extend({
+  firstName: z.string().openapi({ example: 'John' }),
+  lastName: z.string().openapi({ example: 'Doe' }),
+  email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+  phone: PhoneNumberData.nullable().openapi({ example: '+12124567890' }),
+  isDefault: z.boolean().openapi({ example: false }),
+  userId: z
+    .lazy(() => userIdSchema)
+    .nullable()
+    .openapi({ example: 'user_01je6ht4b8fbmttkzh2hs82xqp' }),
+  user: z
+    .lazy(() => UserZod)
+    .optional()
+    .nullable(),
+});
+
+export type IAccountManagerZod = z.infer<typeof IAccountManagerZod>;
+
+export const PostAccountManagerZod = z.object({
+  firstName: z.string().min(1).max(255).openapi({ example: 'John' }),
+  lastName: z.string().min(1).max(255).openapi({ example: 'Doe' }),
+  email: z.string().email().openapi({ example: 'john.doe@example.com' }),
+  phone: PhoneZodSchema.nullable()
+    .optional()
+    .openapi({ example: '+12124567890' }),
+  isDefault: z.boolean().openapi({ example: false }),
+});
+
+export type PostAccountManagerZod = z.infer<typeof PostAccountManagerZod>;
+
+export const PatchAccountManagerZod = z.object({
+  firstName: z.string().min(1).max(255).optional().openapi({ example: 'John' }),
+  lastName: z.string().min(1).max(255).optional().openapi({ example: 'Doe' }),
+  email: z
+    .string()
+    .email()
+    .optional()
+    .openapi({ example: 'john.doe@example.com' }),
+  phone: PhoneZodSchema.nullable()
+    .optional()
+    .openapi({ example: '+12124567890' }),
+  isDefault: z.boolean().optional().openapi({ example: false }),
+});
+export type PatchAccountManagerZod = z.infer<typeof PatchAccountManagerZod>;
+
+export const IPaginatedAccountManager = z.object({
+  items: z.array(IAccountManagerZod),
+  meta: IPaginationMeta,
+});
+export type IPaginatedAccountManager = z.infer<typeof IPaginatedAccountManager>;
+
+export const AccountManagerDeleteResponse = z.object({
+  status: z.boolean().openapi({ example: true }),
+});
+export type AccountManagerDeleteResponse = z.infer<
+  typeof AccountManagerDeleteResponse
+>;
+export const SetDefaultAccountManagerForAllAccountsResponse = z.object({
+  message: z
+    .string()
+    .openapi({ example: 'Default account manager set for all accounts' }),
+});
+export type SetDefaultAccountManagerForAllAccountsResponse = z.infer<
+  typeof SetDefaultAccountManagerForAllAccountsResponse
+>;
+
+export const AccountManagerDeleteQuery = z.object({
+  reassignTo: accountManagerIdSchema
+    .nullable()
+    .optional()
+    .openapi({ example: 'account_manager_01j5y5ghx5fg68d663j1fvy2x7' }),
+});
+export type AccountManagerDeleteQuery = z.infer<
+  typeof AccountManagerDeleteQuery
+>;