@dalmore/api-contracts 0.0.0-dev.58a860b → 0.0.0-dev.64aba85

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

@@ -1,374 +0,0 @@
-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/common/types/notion-database.types.ts

@@ -1,125 +0,0 @@
-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> {}