@dalmore/api-contracts 1.0.7 → 1.0.8

package/src/common/types/notion-page.types.ts

@@ -0,0 +1,267 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta } from './common.types';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { notionDatabaseIdSchema } from './notion-database.types';
+import {
+  NotionPageObjectZod,
+  NotionPagePropertiesZod,
+} from './notion-api.types';
+extendZodWithOpenApi(z);
+
+export const notionPageIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'notion_page';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid notion_page ID format. Must be a valid TypeID with "notion_page" prefix. Example: notion_page_01j5y5ghx5fg68d663j1fvy2x7',
+  },
+);
+
+export const NotionPageZod = IBaseEntity.extend({
+  notionDatabaseId: notionDatabaseIdSchema,
+  name: z
+    .string({ message: 'Name field is required.' })
+    .min(2, { message: 'Name must have at least 2 characters.' })
+    .max(50, { message: 'Name cannot exceed 50 characters.' })
+    .openapi({ example: 'Page name' }),
+  tid: z
+    .string({ message: 'TID field is required.' })
+    .min(2, { message: 'TID must have at least 2 characters.' })
+    .max(50, { message: 'TID cannot exceed 50 characters.' })
+    .openapi({ example: 'page_tid' }),
+  display: z
+    .boolean({ message: 'Display field is required.' })
+    .openapi({ example: true }),
+});
+
+export const PostNotionPageSchema = z.object({
+  notionDatabaseId: notionDatabaseIdSchema,
+  name: z
+    .string({ message: 'Name field is required.' })
+    .min(2, { message: 'Name must have at least 2 characters.' })
+    .max(50, { message: 'Name cannot exceed 50 characters.' })
+    .openapi({ example: 'Page name' }),
+  tid: z
+    .string({ message: 'TID field is required.' })
+    .min(2, { message: 'TID must have at least 2 characters.' })
+    .max(50, { message: 'TID cannot exceed 50 characters.' })
+    .openapi({ example: 'page_tid' }),
+  display: z
+    .boolean({ message: 'Display field must be a boolean.' })
+    .optional()
+    .openapi({ example: true }),
+});
+
+export const UpdateNotionPageSchema = z.object({
+  name: z
+    .string()
+    .min(2, { message: 'Name must have at least 2 characters.' })
+    .max(50, { message: 'Name cannot exceed 50 characters.' })
+    .optional()
+    .openapi({ example: 'Page name' }),
+  tid: z
+    .string()
+    .min(2, { message: 'TID must have at least 2 characters.' })
+    .max(50, { message: 'TID cannot exceed 50 characters.' })
+    .optional()
+    .openapi({ example: 'page_tid' }),
+  display: z.boolean().optional().openapi({ example: true }),
+});
+
+export const NotionPageFiltersZod = z.object({
+  search: z
+    .string({ message: 'Search field must be a string.' })
+    .max(50, { message: 'Search cannot exceed 50 characters.' })
+    .optional()
+    .openapi({ example: 'search term' }),
+});
+
+export const IPaginatedNotionPages = z.object({
+  items: z.array(NotionPageZod),
+  meta: IPaginationMeta,
+});
+
+export const NotionPageDropdownZod = z.object({
+  id: notionPageIdSchema,
+  name: z.string(),
+  databaseName: z.string(),
+});
+
+const notionPageInclude = z.enum(['notionDatabase']);
+
+/**
+ * @description Query parameters for including related entities
+ * @example in contract use as -> query: z.object({}).merge(NotionPageIncludeQuery),
+ */
+export const NotionPageIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          notionPageInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${notionPageInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${notionPageInclude.options.join(',')}`,
+    }),
+});
+
+/**
+ * @see https://developers.notion.com/reference/rich-text
+ */
+export const NotionRichTextSchema = z.object({
+  type: z.literal('text'),
+  text: z.object({
+    content: z.string(),
+    link: z
+      .object({
+        url: z.string(),
+      })
+      .nullable(),
+  }),
+  annotations: z.object({
+    bold: z.boolean(),
+    italic: z.boolean(),
+    strikethrough: z.boolean(),
+    underline: z.boolean(),
+    code: z.boolean(),
+    color: z.string(),
+  }),
+  plain_text: z.string(),
+  href: z.string().nullable(),
+});
+
+export const NotionUserSchema = z.object({
+  object: z.literal('user'),
+  id: z.string(),
+});
+
+export const NotionParentSchema = z.union([
+  z.object({
+    type: z.literal('page_id'),
+    page_id: z.string(),
+  }),
+  z.object({
+    type: z.literal('block_id'),
+    block_id: z.string(),
+  }),
+]);
+
+export const NotionBaseBlockSchema = z.object({
+  object: z.literal('block'),
+  id: z.string(),
+  parent: NotionParentSchema,
+  created_time: z.string(),
+  last_edited_time: z.string(),
+  created_by: NotionUserSchema,
+  last_edited_by: NotionUserSchema,
+  has_children: z.boolean(),
+  archived: z.boolean(),
+  in_trash: z.boolean(),
+});
+
+export const NotionParagraphBlockSchema = NotionBaseBlockSchema.extend({
+  type: z.literal('paragraph'),
+  paragraph: z.object({
+    rich_text: z.array(NotionRichTextSchema),
+    color: z.string(),
+  }),
+  children: z.array(z.lazy(() => NotionGenericBlockSchema)).optional(),
+});
+
+export const NotionTableBlockSchema = NotionBaseBlockSchema.extend({
+  type: z.literal('table'),
+  table: z.object({
+    table_width: z.number(),
+    has_column_header: z.boolean(),
+    has_row_header: z.boolean(),
+  }),
+  children: z.array(z.lazy(() => NotionGenericBlockSchema)).optional(),
+});
+
+export const NotionBulletedListItemBlockSchema = NotionBaseBlockSchema.extend({
+  type: z.literal('bulleted_list_item'),
+  bulleted_list_item: z.object({
+    rich_text: z.array(NotionRichTextSchema),
+    color: z.string(),
+  }),
+  children: z.array(z.lazy(() => NotionGenericBlockSchema)).optional(),
+});
+
+export const NotionNumberedListItemBlockSchema = NotionBaseBlockSchema.extend({
+  type: z.literal('numbered_list_item'),
+  numbered_list_item: z.object({
+    rich_text: z.array(NotionRichTextSchema),
+    color: z.string(),
+  }),
+  children: z.array(z.lazy(() => NotionGenericBlockSchema)).optional(),
+});
+
+export const NotionGenericBlockSchema = NotionBaseBlockSchema.extend({
+  type: z.string(),
+  children: z.array(z.lazy(() => NotionGenericBlockSchema)).optional(),
+}).and(z.record(z.unknown()));
+
+export const NotionPageSchema = z.object({
+  id: z.string(),
+  title: z.string(),
+  properties: NotionPagePropertiesZod,
+});
+
+export const NotionDatabaseInfoSchema = z.object({
+  id: z.string(),
+  name: z.string(),
+  tid: z.string(),
+});
+
+// Response type for page content
+export const NotionPageContentResponseSchema = z.object({
+  object: z.literal('list'),
+  results: z.array(NotionGenericBlockSchema),
+  page: NotionPageSchema,
+  page_object: NotionPageObjectZod,
+  database: NotionDatabaseInfoSchema.optional(),
+  next_cursor: z.string().nullable(),
+  has_more: z.boolean(),
+});
+
+export type INotionPage = z.infer<typeof NotionPageZod>;
+export type PostNotionPage = z.infer<typeof PostNotionPageSchema>;
+export type UpdateNotionPage = z.infer<typeof UpdateNotionPageSchema>;
+export type IPaginatedNotionPage = z.infer<typeof IPaginatedNotionPages>;
+export type INotionPageDropdown = z.infer<typeof NotionPageDropdownZod>;
+export interface NotionPageIncludeQuery
+  extends z.infer<typeof NotionPageIncludeQuery> {}
+
+export type NotionRichText = z.infer<typeof NotionRichTextSchema>;
+export type NotionUser = z.infer<typeof NotionUserSchema>;
+export type NotionParent = z.infer<typeof NotionParentSchema>;
+export type NotionParagraphBlock = z.infer<typeof NotionParagraphBlockSchema>;
+export type NotionTableBlock = z.infer<typeof NotionTableBlockSchema>;
+export type NotionBulletedListItemBlock = z.infer<
+  typeof NotionBulletedListItemBlockSchema
+>;
+export type NotionNumberedListItemBlock = z.infer<
+  typeof NotionNumberedListItemBlockSchema
+>;
+
+export type NotionGenericBlock = z.infer<typeof NotionGenericBlockSchema>;
+export type NotionPage = z.infer<typeof NotionPageSchema>;
+export type NotionDatabaseInfo = z.infer<typeof NotionDatabaseInfoSchema>;
+export type NotionPageContentResponse = z.infer<
+  typeof NotionPageContentResponseSchema
+>;

package/src/common/types/offering-reports.types.ts

@@ -0,0 +1,153 @@
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { TypeID } from 'typeid-js';
+import { z } from 'zod';
+import { accountIdSchema } from './account.types';
+import { dateSchema, IPaginationMeta } from './common.types';
+import { IBaseEntity } from './entity.types';
+import { IIssuer, issuerIdSchema } from './issuer.types';
+
+extendZodWithOpenApi(z);
+
+export const OfferingReportsFiltersZod = z.object({
+  issuerId: z.lazy(() => issuerIdSchema).optional(),
+  reportGeneratedAt: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type OfferingReportsFiltersZod = z.infer<
+  typeof OfferingReportsFiltersZod
+>;
+
+export const OfferingReportsGroupedByIssuerFiltersZod = z.object({
+  issuerId: z.lazy(() => issuerIdSchema).optional(),
+  accountId: z.lazy(() => accountIdSchema).optional(),
+  status: z
+    .enum(['Active', 'Inactive'])
+    .optional()
+    .transform((val) => {
+      if (val === undefined) return undefined;
+      return val === 'Active';
+    }),
+  from: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  to: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+export type OfferingReportsGroupedByIssuerFiltersZod = z.infer<
+  typeof OfferingReportsGroupedByIssuerFiltersZod
+>;
+
+export const offeringReportIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'offering_report';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid offering report ID format. Must be a valid TypeID with "offering_report" prefix.',
+  },
+);
+
+export const IOfferingReports = IBaseEntity.extend({
+  id: offeringReportIdSchema,
+  issuerId: z.lazy(() => issuerIdSchema).optional(),
+  issuer: z
+    .lazy(() => IIssuer)
+    .optional()
+    .nullable(),
+  reportGeneratedAt: z.date().nullable(),
+  totalOfferings: z.number().nullable(),
+  totalAmountRaised: z.number().nullable(),
+  totalInvestors: z.number().nullable(),
+  totalTrades: z.number().nullable(),
+  activeOfferings: z.number().nullable(),
+  avgAmountPerOffering: z.number().nullable(),
+  avgInvestorsPerOffering: z.number().nullable(),
+  reportData: z.any().nullable(),
+});
+export type IOfferingReports = z.infer<typeof IOfferingReports>;
+
+export const IPaginatedComplianceOfferingReports = z.object({
+  items: z.array(IOfferingReports),
+  meta: IPaginationMeta,
+});
+
+export const IOfferingReportsGroupedByIssuer = IOfferingReports.omit({
+  id: true,
+  issuer: true,
+}).extend({
+  accountId: z.lazy(() => accountIdSchema).optional(),
+  accountName: z.string().nullable(),
+  issuerLegalName: z.string().nullable(),
+  issuerDba: z.string().nullable(),
+});
+
+export type IOfferingReportsGroupedByIssuer = z.infer<
+  typeof IOfferingReportsGroupedByIssuer
+>;
+
+export const IPaginatedComplianceOfferingReportsGroupedByIssuer = z.object({
+  items: z.array(IOfferingReportsGroupedByIssuer),
+  meta: IPaginationMeta,
+});
+
+export const GetGrowthMetricsFiltersZod = z.object({
+  days: z.coerce.number().optional(),
+});
+
+export type GetGrowthMetricsFiltersZod = z.infer<
+  typeof GetGrowthMetricsFiltersZod
+>;
+
+export const IGrowthMetrics = z.object({
+  date: z.date().nullable(),
+  totalAmountRaised: z.number().nullable(),
+  dailyGrowth: z.number().nullable(),
+  growthPercentage: z.number().nullable(),
+  newInvestors: z.number().nullable(),
+  newTrades: z.number().nullable(),
+});
+export type IGrowthMetrics = z.infer<typeof IGrowthMetrics>;
+
+export const GetTimeSeriesMetricsFiltersZod = z.object({
+  days: z.coerce.number().optional(),
+  startDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+  endDate: dateSchema.optional().openapi({ example: 'MM/DD/YYYY' }),
+});
+
+export type GetTimeSeriesMetricsFiltersZod = z.infer<
+  typeof GetTimeSeriesMetricsFiltersZod
+>;
+export enum ExportOfferingReportsGroupedByIssuerType {
+  REPORT_DATA = 'REPORT_DATA',
+  REPORT_DATA_WITH_OFFERING = 'REPORT_DATA_WITH_OFFERING',
+}
+
+export const ITimeSeriesMetrics = z.object({
+  date: z.date().nullable(),
+  totalRaised: z.number().nullable(),
+  totalInvestors: z.number().nullable(),
+  totalOfferings: z.number().nullable(),
+  activeOfferings: z.number().nullable(),
+  totalTrades: z.number().nullable(),
+  avgAmountPerOffering: z.number().nullable(),
+  avgInvestorsPerOffering: z.number().nullable(),
+});
+export type ITimeSeriesMetrics = z.infer<typeof ITimeSeriesMetrics>;
+
+export const ExportOfferingReportsGroupedByIssuerFiltersZod = z
+  .object({
+    type: z.nativeEnum(ExportOfferingReportsGroupedByIssuerType),
+  })
+  .merge(OfferingReportsGroupedByIssuerFiltersZod);
+export type ExportOfferingReportsGroupedByIssuerFiltersZod = z.infer<
+  typeof ExportOfferingReportsGroupedByIssuerFiltersZod
+>;
+
+export const ExportOfferingReportsResponse = z.object({
+  message: z.string(),
+});
+
+export type ExportOfferingReportsResponse = z.infer<
+  typeof ExportOfferingReportsResponse
+>;