@dalmore/api-contracts 0.0.0-dev.5e42638 → 0.0.0-dev.685c0b3

package/common/types/api-keys.types.ts

@@ -1,69 +0,0 @@
-import { z } from 'zod';
-import { TypeID } from 'typeid-js';
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { IBaseEntity } from './entity.types';
-import { IPaginationMeta, PortalType } from './common.types';
-import { accountIdSchema } from './account.types';
-extendZodWithOpenApi(z);
-
-export const apiKeyIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'api_key';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message:
-      'Invalid Api Key ID format. Must be a valid TypeID with "api_key" prefix. Example: api_key_01j5y5ghx8fvc83dmx3pznq7hv',
-  },
-);
-
-export const ApiKeyZod = IBaseEntity.extend({
-  id: apiKeyIdSchema,
-  name: z.string(),
-  description: z.string().nullable(),
-  key: z.string(),
-  keyHash: z.string(),
-  active: z.boolean(),
-  lastUsedAt: z.date().nullable(),
-  accountId: z.string(),
-  roleId: z.string().nullable(),
-});
-export type ApiKeyZod = z.infer<typeof ApiKeyZod>;
-
-export const IPaginatedApiKeys = z.object({
-  items: z.array(ApiKeyZod),
-  meta: IPaginationMeta,
-});
-export type IPaginatedApiKeys = z.infer<typeof IPaginatedApiKeys>;
-
-export const PostApiKeyBody = z.object({
-  name: z
-    .string()
-    .min(2, 'name is less than 2 characters')
-    .max(30, 'name is more than 30 characters')
-    .openapi({ description: 'Name of the API key' }),
-  description: z
-    .string()
-    .min(2, 'description is less than 2 characters')
-    .max(50, 'description is more than 50 characters')
-    .optional()
-    .openapi({ description: 'Description of the API key' }),
-  accountId: accountIdSchema,
-  contract: z
-    .enum([
-      PortalType.CLIENT,
-      PortalType.SECONDARIES,
-      PortalType.COMPLIANCE_APIKEY,
-    ])
-    .default(PortalType.CLIENT),
-});
-export type PostApiKeyBody = z.infer<typeof PostApiKeyBody>;
-
-//It removes accountId because issuers use user.accountId from authentication, so the request body shouldn't include it.
-export const PostIssuerApiKeyBody = PostApiKeyBody.omit({ accountId: true });
-
-export type PostIssuerApiKeyBody = z.infer<typeof PostIssuerApiKeyBody>;

package/common/types/asset.types.ts

@@ -1,338 +0,0 @@
-import { extendZodWithOpenApi } from '@anatine/zod-openapi';
-import { TypeID } from 'typeid-js';
-import { z } from 'zod';
-import { accountIdSchema } from './account.types';
-import {
-  AccountZod,
-  AssetType,
-  DurationType,
-  IPaginationMeta,
-  SortBy,
-  SortOrder,
-} from './common.types';
-import { IBaseEntity } from './entity.types';
-import { IOffering, offeringIdSchema } from './offering.types';
-import { issuerIdSchema } from './issuer.types';
-
-extendZodWithOpenApi(z);
-
-export const assetIdSchema = z.string().refine(
-  (value) => {
-    try {
-      const tid = TypeID.fromString(value);
-      return tid.getType() === 'asset';
-    } catch {
-      return false;
-    }
-  },
-  {
-    message: `Invalid asset ID format. Must be a valid TypeID with "asset" prefix. Example: asset_01j5y5ghx5fg68d663j1fvy2x7`,
-  },
-);
-export enum AssetTemplateType {
-  STANDARD = 'STANDARD',
-  TIERED = 'TIERED',
-}
-
-export const IAsset = IBaseEntity.extend({
-  id: assetIdSchema,
-  name: z.string(),
-  type: z.nativeEnum(AssetType).nullable(),
-  pricePerUnit: z.number().nullable(),
-  totalUnits: z.number().nullable(),
-  totalAmount: z.number().nullable(),
-  yield: z.number().nullable(),
-  duration: z.number().nullable(),
-  durationType: z.nativeEnum(DurationType).nullable(),
-  accountId: z.string(),
-  account: AccountZod.optional().nullable(),
-  offeringId: z.string(),
-  offering: z
-    .lazy(() => IOffering)
-    .optional()
-    .nullable(), // Use z.lazy here
-  template: z.nativeEnum(AssetTemplateType),
-  tiers: z.array(z.number().positive()).nullable(),
-  enableBonus: z.boolean(),
-});
-
-export type IAsset = z.infer<typeof IAsset>;
-
-export const IPaginatedAsset = z.object({
-  items: z.array(IAsset),
-  meta: IPaginationMeta,
-});
-export type IPaginatedAsset = z.infer<typeof IPaginatedAsset>;
-
-const PostAssetBase = z.object({
-  offeringId: z
-    .lazy(() => offeringIdSchema)
-    .openapi({ example: 'offering_01jayn2qkpeebav9gjpqx7xm8j' }),
-  name: z.string().min(2).max(50).openapi({ example: 'Asset name' }),
-  type: z.nativeEnum(AssetType).openapi({ example: AssetType.STOCK }),
-  pricePerUnit: z
-    .number()
-    .min(0.01)
-    .max(10000000000)
-    .nullable()
-    .openapi({ example: 2000 }),
-  totalUnits: z
-    .number()
-    .min(1)
-    .max(10000000000)
-    .nullable()
-    .openapi({ example: 5200 }),
-  yield: z
-    .number()
-    .min(0.01)
-    .max(10000000000)
-    .nullable()
-    .optional()
-    .openapi({ example: 1200 }),
-  duration: z
-    .number()
-    .min(1)
-    .max(1000)
-    .nullable()
-    .optional()
-    .openapi({ example: 1 }),
-  durationType: z
-    .nativeEnum(DurationType)
-    .nullable()
-    .optional()
-    .openapi({ example: DurationType.DAY }),
-  template: z
-    .nativeEnum(AssetTemplateType)
-    .default(AssetTemplateType.STANDARD)
-    .openapi({ example: AssetTemplateType.STANDARD }),
-  tiers: z.array(z.number().positive()).nullable().optional(),
-  enableBonus: z.boolean().default(false).openapi({ example: false }),
-});
-
-export const postAssetRefinement = (data: any, ctx: any) => {
-  // If type is bond, yield and duration must be provided (cannot be null or undefined)
-  if (data.assetType === AssetType.BOND || data.type === AssetType.BOND) {
-    if (data.yield === null || data.yield === undefined) {
-      ctx.addIssue({
-        path: ['yield'],
-        message:
-          'Yield is required for bond type and cannot be null or undefined',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-    if (data.duration === null || data.duration === undefined) {
-      ctx.addIssue({
-        path: ['duration'],
-        message:
-          'Duration is required for bond type and cannot be null or undefined',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-    if (data.durationType === null || data.durationType === undefined) {
-      ctx.addIssue({
-        path: ['durationType'],
-        message:
-          'Duration type is required for bond type and cannot be null or undefined',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-  }
-
-  // If type is stock, yield and duration must be either null or undefined
-  if (data.assetType === AssetType.STOCK || data.type === AssetType.STOCK) {
-    if (data.yield !== null && data.yield !== undefined) {
-      ctx.addIssue({
-        path: ['yield'],
-        message: 'Yield must not be provided for stock type',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-    if (data.duration !== null && data.duration !== undefined) {
-      ctx.addIssue({
-        path: ['duration'],
-        message: 'Duration must not be provided for stock type',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-    if (data.durationType !== null && data.durationType !== undefined) {
-      ctx.addIssue({
-        path: ['durationType'],
-        message: 'Duration type must not be provided for stock type',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-  }
-  if (data.template === AssetTemplateType.TIERED) {
-    if (data.tiers === null || data.tiers === undefined) {
-      ctx.addIssue({
-        path: ['tiers'],
-        message: 'Tiers must be provided for TIERED template',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-  }
-  // If template is STANDARD, tiers must be null or undefined
-  if (data.template === AssetTemplateType.STANDARD) {
-    if (data.tiers !== null && data.tiers !== undefined) {
-      ctx.addIssue({
-        path: ['tiers'],
-        message: 'Tiers must not be provided for STANDARD template',
-        code: z.ZodIssueCode.custom,
-      });
-    }
-  }
-};
-
-export const PostAsset = PostAssetBase.superRefine(postAssetRefinement);
-
-export type PostAsset = z.infer<typeof PostAsset>;
-
-export const CompliancePostAsset = PostAssetBase.extend({
-  accountId: accountIdSchema,
-}).superRefine(postAssetRefinement);
-
-export type CompliancePostAsset = z.infer<typeof CompliancePostAsset>;
-
-export const PutAsset = z.object({
-  name: z.string().min(2).max(50).optional().openapi({ example: 'Z' }),
-  type: z
-    .nativeEnum(AssetType)
-    .optional()
-    .openapi({ example: AssetType.STOCK }),
-  pricePerUnit: z
-    .number()
-    .min(0.01)
-    .max(10000000000)
-    .nullable()
-    .optional()
-    .openapi({ example: 2000 }),
-  totalUnits: z
-    .number()
-    .min(1)
-    .max(10000000000)
-    .nullable()
-    .optional()
-    .openapi({ example: 5200 }),
-  yield: z
-    .number()
-    .min(0.01)
-    .max(10000000000)
-    .nullable()
-    .optional()
-    .openapi({ example: 1200 }),
-  duration: z
-    .number()
-    .min(1)
-    .max(1000)
-    .nullable()
-    .optional()
-    .openapi({ example: 1 }),
-  durationType: z
-    .nativeEnum(DurationType)
-    .nullable()
-    .optional()
-    .openapi({ example: DurationType.DAY }),
-  template: z
-    .nativeEnum(AssetTemplateType)
-    .default(AssetTemplateType.STANDARD)
-    .openapi({ example: AssetTemplateType.STANDARD })
-    .nullable()
-    .optional(),
-  tiers: z.array(z.number().positive()).nullable().optional(),
-  enableBonus: z.boolean().optional().openapi({ example: false }),
-});
-
-export type PutAsset = z.infer<typeof PutAsset>;
-
-export const CompliancePutAsset = PutAsset.merge(
-  z.object({ accountId: accountIdSchema }),
-);
-export type CompliancePutAsset = z.infer<typeof CompliancePutAsset>;
-
-const assetsInclude = z.enum(['account', 'offering', 'bonusTiers']);
-
-export const AssetsIncludeQuery = z.object({
-  include: z
-    .string()
-    .optional()
-    .transform((str) => (str ? str.split(',') : []))
-    .refine(
-      (includes) =>
-        includes.every((include) =>
-          assetsInclude.options.includes(include as any),
-        ),
-      {
-        message: `Invalid include option provided. Valid options are: ${assetsInclude.options.join(',')}`,
-      },
-    )
-    .openapi({
-      example: `${assetsInclude.options.join(', ')}`,
-    }),
-});
-export interface AssetsIncludeQuery
-  extends z.infer<typeof AssetsIncludeQuery> {}
-
-export const AssetFiltersZod = z.object({
-  name: z.string().optional(),
-  accountId: accountIdSchema.optional(),
-  offeringId: z
-    .lazy(() => offeringIdSchema)
-    .openapi({ example: 'offering_01jayn2qkpeebav9gjpqx7xm8j' })
-    .optional(),
-  issuerId: z.lazy(() => issuerIdSchema).optional(),
-  type: z.nativeEnum(AssetType).optional(),
-});
-export type AssetFiltersZod = z.infer<typeof AssetFiltersZod>;
-
-export const AssetSortZod = z.object({
-  sort: z.enum([SortBy.NAME, SortBy.CREATED_AT, SortBy.UPDATED_AT]).optional(),
-  dir: z.nativeEnum(SortOrder).optional(),
-});
-export type AssetSortZod = z.infer<typeof AssetSortZod>;
-
-const BaseAssetSummarySchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  accountId: accountIdSchema,
-  offeringId: offeringIdSchema,
-  issuerId: z.lazy(() => issuerIdSchema).nullable(),
-  pricePerUnit: z.number().nullable(),
-  totalUnits: z.number().nullable(),
-});
-
-export const StockAssetSchema = BaseAssetSummarySchema.extend({
-  type: z.literal(AssetType.STOCK),
-});
-export type StockAssetSchema = z.infer<typeof StockAssetSchema>;
-
-const BondAssetSchema = BaseAssetSummarySchema.extend({
-  type: z.literal(AssetType.BOND).nullable(),
-  yield: z.number().nullable(),
-  duration: z.number().nullable(),
-  durationType: z.nativeEnum(DurationType).nullable(),
-});
-
-export const AssetSummarySchema = z.discriminatedUnion('type', [
-  StockAssetSchema,
-  BondAssetSchema,
-]);
-export type AssetSummarySchema = z.infer<typeof AssetSummarySchema>;
-
-export const IPaginatedAssetSummary = z.object({
-  items: z.array(AssetSummarySchema),
-  meta: IPaginationMeta,
-});
-
-export type IPaginatedAssetSummary = z.infer<typeof IPaginatedAssetSummary>;
-
-export const AssetSummaryFiltersZod = z.object({
-  accountId: accountIdSchema.optional(),
-  issuerId: z.lazy(() => issuerIdSchema).optional(),
-  offeringId: z
-    .lazy(() => offeringIdSchema)
-    .openapi({ example: 'offering_01jayn2qkpeebav9gjpqx7xm8j' })
-    .optional(),
-  type: z.nativeEnum(AssetType),
-  name: z.string().optional(),
-});
-export type AssetSummaryFiltersZod = z.infer<typeof AssetSummaryFiltersZod>;