@dalmore/api-contracts 1.0.7 → 1.0.8

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

@@ -0,0 +1,374 @@
+import { z } from 'zod';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { NotionDatabaseZod } from './notion-database.types';
+import { LogContextZod } from './common.types';
+
+extendZodWithOpenApi(z);
+
+// Notion API Types - Based on official Notion API specification
+// https://developers.notion.com/reference/post-database-query
+
+export const NotionTextFilterZod = z.object({
+  equals: z.string().optional(),
+  does_not_equal: z.string().optional(),
+  contains: z.string().optional(),
+  does_not_contain: z.string().optional(),
+  starts_with: z.string().optional(),
+  ends_with: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionNumberFilterZod = z.object({
+  equals: z.number().optional(),
+  does_not_equal: z.number().optional(),
+  greater_than: z.number().optional(),
+  less_than: z.number().optional(),
+  greater_than_or_equal_to: z.number().optional(),
+  less_than_or_equal_to: z.number().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionSelectFilterZod = z.object({
+  equals: z.string().optional(),
+  does_not_equal: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionDateFilterZod = z.object({
+  equals: z.string().optional(),
+  before: z.string().optional(),
+  after: z.string().optional(),
+  on_or_before: z.string().optional(),
+  on_or_after: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+  past_week: z.object({}).optional(),
+  past_month: z.object({}).optional(),
+  past_year: z.object({}).optional(),
+  next_week: z.object({}).optional(),
+  next_month: z.object({}).optional(),
+  next_year: z.object({}).optional(),
+});
+
+export const NotionCheckboxFilterZod = z.object({
+  equals: z.boolean().optional(),
+  does_not_equal: z.boolean().optional(),
+});
+
+export const NotionFilesFilterZod = z.object({
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionRelationFilterZod = z.object({
+  contains: z.string().optional(),
+  does_not_contain: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionPeopleFilterZod = z.object({
+  contains: z.string().optional(),
+  does_not_contain: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionCreatedByUserFilterZod = z.object({
+  contains: z.string().optional(),
+  does_not_contain: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+export const NotionLastEditedByUserFilterZod = z.object({
+  contains: z.string().optional(),
+  does_not_contain: z.string().optional(),
+  is_empty: z.boolean().optional(),
+  is_not_empty: z.boolean().optional(),
+});
+
+// Property Filter - must have property name and exactly one filter type
+export const NotionPropertyFilterZod = z
+  .object({
+    property: z.string(),
+  })
+  .and(
+    z.union([
+      z.object({ text: NotionTextFilterZod }),
+      z.object({ number: NotionNumberFilterZod }),
+      z.object({ select: NotionSelectFilterZod }),
+      z.object({ date: NotionDateFilterZod }),
+      z.object({ checkbox: NotionCheckboxFilterZod }),
+      z.object({ url: NotionTextFilterZod }),
+      z.object({ email: NotionTextFilterZod }),
+      z.object({ phone_number: NotionTextFilterZod }),
+      z.object({ files: NotionFilesFilterZod }),
+      z.object({ relation: NotionRelationFilterZod }),
+      z.object({ people: NotionPeopleFilterZod }),
+    ]),
+  );
+
+// Timestamp Filters
+export const NotionCreatedTimeFilterZod = z.object({
+  created_time: NotionDateFilterZod,
+});
+
+export const NotionLastEditedTimeFilterZod = z.object({
+  last_edited_time: NotionDateFilterZod,
+});
+
+export const NotionCreatedByFilterZod = z.object({
+  created_by: NotionCreatedByUserFilterZod,
+});
+
+export const NotionLastEditedByFilterZod = z.object({
+  last_edited_by: NotionLastEditedByUserFilterZod,
+});
+
+// Compound Filters
+export const NotionCompoundFilterZod = z.object({
+  and: z.array(z.lazy(() => NotionFilterZod)).optional(),
+  or: z.array(z.lazy(() => NotionFilterZod)).optional(),
+  not: z.lazy(() => NotionFilterZod).optional(),
+});
+
+// Main Filter Union
+export const NotionFilterZod = z.union([
+  NotionPropertyFilterZod,
+  NotionCreatedTimeFilterZod,
+  NotionLastEditedTimeFilterZod,
+  NotionCreatedByFilterZod,
+  NotionLastEditedByFilterZod,
+  NotionCompoundFilterZod,
+]);
+
+// Sort Types
+export const NotionPropertySortZod = z.object({
+  property: z.string(),
+  direction: z.enum(['ascending', 'descending']),
+});
+
+export const NotionTimestampSortZod = z.object({
+  timestamp: z.enum(['created_time', 'last_edited_time']),
+  direction: z.enum(['ascending', 'descending']),
+});
+
+export const NotionSortZod = z.union([
+  NotionPropertySortZod,
+  NotionTimestampSortZod,
+]);
+
+// Database Query Options
+export const NotionDatabaseQueryOptionsZod = z.object({
+  page_size: z.number().min(1).max(100).optional(),
+  start_cursor: z.string().optional(),
+  filter: NotionFilterZod.optional(),
+  sorts: z.array(NotionSortZod).optional(),
+});
+
+// Response Types
+export const NotionPageObjectZod = z.object({
+  object: z.literal('page'),
+  id: z.string(),
+  created_time: z.string(),
+  last_edited_time: z.string(),
+  created_by: z
+    .object({
+      object: z.literal('user'),
+      id: z.string(),
+    })
+    .optional(),
+  last_edited_by: z
+    .object({
+      object: z.literal('user'),
+      id: z.string(),
+    })
+    .optional(),
+  properties: z.lazy(() => NotionPagePropertiesZod),
+  parent: z.object({
+    type: z.literal('database_id'),
+    database_id: z.string(),
+  }),
+  url: z.string(),
+  public_url: z.string().nullable(),
+  archived: z.boolean(),
+});
+
+export const NotionDatabaseQueryResponseZod = z.object({
+  object: z.literal('list'),
+  results: z.array(NotionPageObjectZod),
+  next_cursor: z.string().nullable(),
+  has_more: z.boolean(),
+  type: z.literal('page_or_database'),
+  page_or_database: z.record(z.any()),
+});
+
+export type NotionTextFilter = z.infer<typeof NotionTextFilterZod>;
+export type NotionNumberFilter = z.infer<typeof NotionNumberFilterZod>;
+export type NotionSelectFilter = z.infer<typeof NotionSelectFilterZod>;
+export type NotionDateFilter = z.infer<typeof NotionDateFilterZod>;
+export type NotionCheckboxFilter = z.infer<typeof NotionCheckboxFilterZod>;
+export type NotionFilesFilter = z.infer<typeof NotionFilesFilterZod>;
+export type NotionRelationFilter = z.infer<typeof NotionRelationFilterZod>;
+export type NotionPeopleFilter = z.infer<typeof NotionPeopleFilterZod>;
+export type NotionCreatedByUserFilter = z.infer<
+  typeof NotionCreatedByUserFilterZod
+>;
+export type NotionLastEditedByUserFilter = z.infer<
+  typeof NotionLastEditedByUserFilterZod
+>;
+export type NotionCreatedByFilter = z.infer<typeof NotionCreatedByFilterZod>;
+export type NotionLastEditedByFilter = z.infer<
+  typeof NotionLastEditedByFilterZod
+>;
+export type NotionPropertyFilter = z.infer<typeof NotionPropertyFilterZod>;
+export type NotionCreatedTimeFilter = z.infer<
+  typeof NotionCreatedTimeFilterZod
+>;
+export type NotionLastEditedTimeFilter = z.infer<
+  typeof NotionLastEditedTimeFilterZod
+>;
+export type NotionCompoundFilter = z.infer<typeof NotionCompoundFilterZod>;
+export type NotionFilter = z.infer<typeof NotionFilterZod>;
+export type NotionPropertySort = z.infer<typeof NotionPropertySortZod>;
+export type NotionTimestampSort = z.infer<typeof NotionTimestampSortZod>;
+export type NotionSort = z.infer<typeof NotionSortZod>;
+export type NotionDatabaseQueryOptions = z.infer<
+  typeof NotionDatabaseQueryOptionsZod
+>;
+export type NotionPageObject = z.infer<typeof NotionPageObjectZod>;
+export type NotionDatabaseQueryResponse = z.infer<
+  typeof NotionDatabaseQueryResponseZod
+>;
+
+// Notion Page Property Types
+export const NotionRichTextItemZod = 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 NotionTitlePropertyValueZod = z.object({
+  id: z.string(),
+  type: z.literal('title'),
+  title: z.array(NotionRichTextItemZod),
+});
+
+export const NotionRichTextPropertyValueZod = z.object({
+  id: z.string(),
+  type: z.literal('rich_text'),
+  rich_text: z.array(NotionRichTextItemZod),
+});
+
+export const NotionSelectPropertyValueZod = z.object({
+  id: z.string(),
+  type: z.literal('select'),
+  select: z
+    .object({
+      id: z.string(),
+      name: z.string(),
+      color: z.string(),
+    })
+    .nullable(),
+});
+
+export const NotionNumberPropertyValueZod = z.object({
+  id: z.string(),
+  type: z.literal('number'),
+  number: z.number().nullable(),
+});
+
+export const NotionCheckboxPropertyValueZod = z.object({
+  id: z.string(),
+  type: z.literal('checkbox'),
+  checkbox: z.boolean(),
+});
+
+export const NotionDatePropertyValueZod = z.object({
+  id: z.string(),
+  type: z.literal('date'),
+  date: z
+    .object({
+      start: z.string(),
+      end: z.string().nullable(),
+      time_zone: z.string().nullable(),
+    })
+    .nullable(),
+});
+
+export const NotionPropertyValueZod = z.union([
+  NotionTitlePropertyValueZod,
+  NotionRichTextPropertyValueZod,
+  NotionSelectPropertyValueZod,
+  NotionNumberPropertyValueZod,
+  NotionCheckboxPropertyValueZod,
+  NotionDatePropertyValueZod,
+  z.object({ type: z.string() }).passthrough(),
+]);
+
+export const NotionPagePropertiesZod = z.record(NotionPropertyValueZod);
+
+// Sync Log Type
+export const NotionSyncLogZod = z.object({
+  success: z.boolean(),
+  pagesCount: z.number().optional(),
+  savedPages: z.number().optional(),
+  timestamp: z.string(),
+  error: z.string().optional(),
+  rawApiResponses: z.array(z.any()).optional(),
+});
+
+// Log Context Type
+export const NotionLogContextZod = LogContextZod.extend({
+  notionDatabaseId: z.string(),
+});
+
+// Page Processing Result Type
+export const NotionPageProcessingResultZod = z.object({
+  notionDatabase: NotionDatabaseZod.nullable(),
+  pagesCount: z.number(),
+  savedPages: z.number(),
+});
+
+export type NotionRichTextItem = z.infer<typeof NotionRichTextItemZod>;
+export type NotionTitlePropertyValue = z.infer<
+  typeof NotionTitlePropertyValueZod
+>;
+export type NotionRichTextPropertyValue = z.infer<
+  typeof NotionRichTextPropertyValueZod
+>;
+export type NotionSelectPropertyValue = z.infer<
+  typeof NotionSelectPropertyValueZod
+>;
+export type NotionNumberPropertyValue = z.infer<
+  typeof NotionNumberPropertyValueZod
+>;
+export type NotionCheckboxPropertyValue = z.infer<
+  typeof NotionCheckboxPropertyValueZod
+>;
+export type NotionDatePropertyValue = z.infer<
+  typeof NotionDatePropertyValueZod
+>;
+export type NotionPropertyValue = z.infer<typeof NotionPropertyValueZod>;
+export type NotionPageProperties = z.infer<typeof NotionPagePropertiesZod>;
+export type NotionSyncLog = z.infer<typeof NotionSyncLogZod>;
+export type NotionLogContext = z.infer<typeof NotionLogContextZod>;
+export type NotionPageProcessingResult = z.infer<
+  typeof NotionPageProcessingResultZod
+>;

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

@@ -0,0 +1,125 @@
+import { z } from 'zod';
+import { TypeID } from 'typeid-js';
+import { extendZodWithOpenApi } from '@anatine/zod-openapi';
+import { IBaseEntity } from './entity.types';
+import { IPaginationMeta } from './common.types';
+
+extendZodWithOpenApi(z);
+
+export const notionDatabaseIdSchema = z.string().refine(
+  (value) => {
+    try {
+      const tid = TypeID.fromString(value);
+      return tid.getType() === 'notion_database';
+    } catch {
+      return false;
+    }
+  },
+  {
+    message:
+      'Invalid notion_database ID format. Must be a valid TypeID with "notion_database" prefix. Example: notion_database_01j5y5ghx5fg68d663j1fvy2x7',
+  },
+);
+
+export const NotionDatabaseZod = IBaseEntity.extend({
+  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: 'Database 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: 'database_tid' }),
+  sync: z
+    .boolean({ message: 'Sync field is required.' })
+    .openapi({ example: true }),
+  display: z
+    .boolean({ message: 'Display field is required.' })
+    .openapi({ example: true }),
+  syncLog: z.string().nullable().openapi({ example: null }),
+});
+
+export const PostNotionDatabaseSchema = z.object({
+  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: 'Database 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: 'database_tid' }),
+  sync: z
+    .boolean({ message: 'Sync field must be a boolean.' })
+    .optional()
+    .openapi({ example: true }),
+  display: z
+    .boolean({ message: 'Display field must be a boolean.' })
+    .optional()
+    .openapi({ example: true }),
+});
+
+export const UpdateNotionDatabaseSchema = z.object({
+  name: z.string().optional().openapi({ example: 'Database name' }),
+  tid: z.string().optional().openapi({ example: 'database_tid' }),
+  sync: z.boolean().optional().openapi({ example: true }),
+  display: z.boolean().optional().openapi({ example: true }),
+});
+
+export const TriggerNotionDatabaseSync = z.object({}).openapi({
+  description: 'Empty body - no additional data required for sync trigger',
+  example: {},
+});
+
+export const NotionDatabaseFiltersZod = 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 IPaginatedNotionDatabases = z.object({
+  items: z.array(NotionDatabaseZod),
+  meta: IPaginationMeta,
+});
+
+const notionDatabaseInclude = z.enum(['notionPages']);
+
+/**
+ * @description Query parameters for including related entities
+ * @example in contract use as -> query: z.object({}).merge(NotionDatabaseIncludeQuery),
+ */
+export const NotionDatabaseIncludeQuery = z.object({
+  include: z
+    .string()
+    .optional()
+    .transform((str) => (str ? str.split(',') : []))
+    .refine(
+      (includes) =>
+        includes.every((include) =>
+          notionDatabaseInclude.options.includes(include as any),
+        ),
+      {
+        message: `Invalid include option provided. Valid options are: ${notionDatabaseInclude.options.join(',')}`,
+      },
+    )
+    .openapi({
+      example: `${notionDatabaseInclude.options.join(',')}`,
+    }),
+});
+
+export type INotionDatabase = z.infer<typeof NotionDatabaseZod>;
+export type PostNotionDatabase = z.infer<typeof PostNotionDatabaseSchema>;
+export type UpdateNotionDatabase = z.infer<typeof UpdateNotionDatabaseSchema>;
+export type TriggerNotionDatabaseSync = z.infer<
+  typeof TriggerNotionDatabaseSync
+>;
+export type IPaginatedNotionDatabase = z.infer<
+  typeof IPaginatedNotionDatabases
+>;
+export interface NotionDatabaseIncludeQuery
+  extends z.infer<typeof NotionDatabaseIncludeQuery> {}