@nx-ddd/notion 19.0.0-preview.9 → 19.1.1

package/index.d.ts

@@ -1,6 +1,593 @@
-export * from './converter';
-export * from './decorators';
-export * from './query';
-export * from './query-builder';
-export * from './repository';
-export * from './utils';
+import * as _notionhq_client_build_src_api_endpoints from '@notionhq/client/build/src/api-endpoints';
+import { PageObjectResponse, PartialPageObjectResponse, PartialDatabaseObjectResponse, DatabaseObjectResponse } from '@notionhq/client/build/src/api-endpoints';
+import { Type, Entity, Repository } from '@nx-ddd/common/domain';
+import * as i0 from '@angular/core';
+import { InjectionToken } from '@angular/core';
+import { Client } from '@notionhq/client';
+import { Observable } from 'rxjs';
+import dayjs from 'dayjs';
+
+declare class NotionHelper {
+    static fromNotion<E>(page: PageObjectResponse | PartialPageObjectResponse | PartialDatabaseObjectResponse | DatabaseObjectResponse, Entity: Type<E>): E;
+    static toNotion<E>(entity: Partial<E>, Entity: Type<E>): object;
+}
+declare abstract class NotionConverter<E> {
+    protected abstract Entity: any;
+    fromNotion(page: PageObjectResponse | PartialPageObjectResponse | PartialDatabaseObjectResponse | DatabaseObjectResponse): E;
+    toNotion(entity: Partial<E>): object;
+}
+declare function createConverter<E = any>(Entity: any): NotionConverter<E>;
+
+declare const NOTION_ANNOTATIONS = "notion_annotations";
+type NotionFieldType = 'title' | 'url' | 'rich_text' | 'relation' | 'status' | 'formula' | 'rollup' | 'timestamp' | 'number' | 'created_time' | 'last_edited_time' | 'date' | 'select' | 'phone_number' | 'email' | 'checkbox' | 'created_by' | 'files' | 'last_edited_by' | 'multi_select' | 'people' | 'unique_id';
+interface NotionAnnotation<T extends object = undefined> {
+    type: NotionFieldType;
+    fieldName: string;
+    propName: string;
+    options?: T;
+}
+declare const Title: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Url: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const RichText: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Relation: (name?: string, options?: Partial<{
+    multi: boolean;
+}>) => (target: any, propName: string) => void;
+declare const Status: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Formula: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Rollup: (name?: string, options?: Partial<{
+    multi: boolean;
+}>) => (target: any, propName: string) => void;
+declare const Timestamp: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Number: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const CreatedTime: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const LastEditedTime: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Date$1: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Select: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const PhoneNumber: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Email: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const UniqueID: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+declare const Notion: {
+    Title: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Url: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    RichText: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Relation: (name?: string, options?: Partial<{
+        multi: boolean;
+    }>) => (target: any, propName: string) => void;
+    Status: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Formula: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Rollup: (name?: string, options?: Partial<{
+        multi: boolean;
+    }>) => (target: any, propName: string) => void;
+    Timestamp: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Number: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    CreatedTime: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    LastEditedTime: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Date: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Select: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    PhoneNumber: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    Email: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+    UniqueID: (name?: string, options?: undefined) => (target: any, propName: string) => void;
+};
+
+declare class NotionService {
+    private config;
+    private notionClient;
+    private cache;
+    retrievePage(pageId: string): Promise<_notionhq_client_build_src_api_endpoints.GetPageResponse>;
+    updatePage(pageId: string, properties: any): Promise<_notionhq_client_build_src_api_endpoints.UpdatePageResponse>;
+    deletePage(pageId: string): Promise<void>;
+    retrieveDatabase(databaseId: string): Promise<_notionhq_client_build_src_api_endpoints.GetDatabaseResponse>;
+    updateDatabase(databaseId: string, properties: any): Promise<_notionhq_client_build_src_api_endpoints.UpdateDatabaseResponse>;
+    retrieveBlock(blockId: string): Promise<_notionhq_client_build_src_api_endpoints.GetBlockResponse>;
+    search(params: Parameters<typeof this$1.notionClient.search>[0]): Promise<_notionhq_client_build_src_api_endpoints.SearchResponse>;
+    queryDatabase(databaseId: string, filter?: any): Promise<(_notionhq_client_build_src_api_endpoints.PageObjectResponse | _notionhq_client_build_src_api_endpoints.PartialPageObjectResponse | _notionhq_client_build_src_api_endpoints.PartialDatabaseObjectResponse | _notionhq_client_build_src_api_endpoints.DatabaseObjectResponse)[]>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotionService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotionService>;
+}
+
+interface NotionConfig {
+    token: string;
+}
+declare const NOTION_SERVICE: InjectionToken<NotionService>;
+declare const NOTION_CONFIG: InjectionToken<NotionConfig>;
+declare function injectNotion(): NotionService;
+
+type Evaluation = '==' | '>' | '>=' | '<' | '<=' | '!=' | 'in';
+declare class N {
+    static RollupPropQuery(property: string, evaluation: Evaluation, value: string | number): {
+        property: string;
+        rollup: {
+            every: {
+                rich_text: {
+                    equals: string | number;
+                };
+            };
+        };
+    };
+    static FormulaQuery(property: string, evaluation: Evaluation, value: string | number): {
+        property: string;
+        formula: {};
+    };
+    static LastEditedTime(property: string, evaluation: Evaluation, value: string | number): {
+        timestamp: string;
+        last_edited_time: {
+            [x: string]: string | number;
+        };
+    };
+    static Timestamp(property: string, evaluation: Evaluation, value: string): {
+        property: string;
+        timestamp: {
+            [x: string]: string;
+        };
+    };
+    static Status(property: string, evaluation: Evaluation, value: string): {
+        property: string;
+        status: {
+            [x: string]: string;
+        };
+    };
+    static Relation(property: string, evaluation: Evaluation, value: string): {
+        property: string;
+        relation: {
+            [x: string]: string;
+        };
+    };
+}
+declare abstract class NotionBaseQuery {
+    type: 'and' | 'or' | 'filter' | 'sort';
+    abstract build(): any;
+}
+declare class NotionFilter extends NotionBaseQuery {
+    propertyType: any;
+    propertyName: string;
+    evaluation: Evaluation;
+    value: string | number;
+    readonly type: "filter";
+    constructor(propertyType: any, propertyName: string, evaluation: Evaluation, value: string | number);
+    build(): {
+        property: string;
+        rollup: {
+            every: {
+                rich_text: {
+                    equals: string | number;
+                };
+            };
+        };
+    } | {
+        property: string;
+        formula: {};
+    } | {
+        timestamp: string;
+        last_edited_time: {
+            [x: string]: string | number;
+        };
+    } | {
+        property: string;
+        status: {
+            [x: string]: string;
+        };
+    } | {
+        property: string;
+        relation: {
+            [x: string]: string;
+        };
+    };
+}
+declare class NotionSort extends NotionBaseQuery {
+    property: string;
+    direction: 'asc' | 'desc';
+    readonly type: "sort";
+    constructor(property: string, direction?: 'asc' | 'desc');
+    build(): {
+        property: string;
+        direction: string;
+    };
+}
+declare class NotionAnd extends NotionBaseQuery {
+    readonly type: "and";
+    arr: NotionFilter[];
+    constructor(...filters: NotionFilter[]);
+    build(): {
+        and: ({
+            property: string;
+            rollup: {
+                every: {
+                    rich_text: {
+                        equals: string | number;
+                    };
+                };
+            };
+        } | {
+            property: string;
+            formula: {};
+        } | {
+            timestamp: string;
+            last_edited_time: {
+                [x: string]: string | number;
+            };
+        } | {
+            property: string;
+            status: {
+                [x: string]: string;
+            };
+        } | {
+            property: string;
+            relation: {
+                [x: string]: string;
+            };
+        })[];
+    };
+}
+declare class NotionOr extends NotionBaseQuery {
+    readonly type: "or";
+    arr: NotionFilter[];
+    constructor(...filters: NotionFilter[]);
+    build(): {
+        or: ({
+            property: string;
+            rollup: {
+                every: {
+                    rich_text: {
+                        equals: string | number;
+                    };
+                };
+            };
+        } | {
+            property: string;
+            formula: {};
+        } | {
+            timestamp: string;
+            last_edited_time: {
+                [x: string]: string | number;
+            };
+        } | {
+            property: string;
+            status: {
+                [x: string]: string;
+            };
+        } | {
+            property: string;
+            relation: {
+                [x: string]: string;
+            };
+        })[];
+    };
+}
+declare const Query: <E = any>(Entity: E) => {
+    Filter: (_propName: string, evaluation: Evaluation, value: string | number) => NotionFilter;
+    OrderBy: (_propName: string, direction: "asc" | "desc") => NotionSort;
+    And: (...args: NotionFilter[]) => NotionAnd;
+    Or: (...args: NotionFilter[]) => NotionOr;
+};
+
+declare class NotionQueryBuilder {
+    constructor();
+    build(filterQuery?: NotionBaseQuery, sortQuery?: NotionBaseQuery): {
+        sorts: any[];
+        filter: any;
+    } | {
+        sorts?: undefined;
+        filter: any;
+    } | {
+        sorts: any[];
+        filter?: undefined;
+    } | {
+        sorts?: undefined;
+        filter?: undefined;
+    };
+    protected buildSortQuery(query: NotionBaseQuery): {
+        sorts: any[];
+    } | {
+        sorts?: undefined;
+    };
+    protected buildFilterQuery(query: NotionBaseQuery): {
+        filter: any;
+    } | {
+        filter?: undefined;
+    };
+}
+
+declare const NOTION_ACCESS_TOKEN: InjectionToken<string>;
+declare const NOTION_DATABASE_ID: InjectionToken<unknown>;
+declare function provideNotionConfig(config: {
+    accessToken: string;
+}): {
+    provide: InjectionToken<string>;
+    useValue: string;
+};
+declare abstract class NotionRepository<E extends Entity> extends Repository<E> {
+    protected abstract databaseId: string;
+    protected abstract converter: NotionConverter<E>;
+    protected token: string;
+    protected client: Client;
+    protected queryBuilder: NotionQueryBuilder;
+    protected get parent(): {
+        type: 'database_id';
+        database_id: string;
+    };
+    query(filterQuery?: NotionBaseQuery, sortQuery?: NotionBaseQuery, startCursor?: string, pageSize?: number): Promise<{
+        results: E[];
+        nextCursor: string;
+        hasMore: boolean;
+    }>;
+    queryV2(args?: any): Promise<{
+        results: E[];
+        nextCursor: string;
+        hasMore: boolean;
+    }>;
+    list({ batchSize, }?: {
+        batchSize?: number;
+    }): Promise<E[]>;
+    listChanges(): Observable<E[]>;
+    get({ id }: {
+        id: string;
+    }): Promise<E>;
+    create(entity: Omit<E, 'id' | 'createdAt' | 'updatedAt'> & Partial<Pick<E, 'id'>>): Promise<E>;
+    createMany(data: Omit<E, 'id' | 'createdAt' | 'updatedAt'>[]): Promise<E[]>;
+    update(entity: Partial<E>): Promise<void>;
+    save(data: Partial<E>): Promise<boolean | [E, boolean]>;
+    saveMany(entities: E[]): Promise<void>;
+    updateMany(data: Partial<E>[]): Promise<void>;
+    delete({ id }: {
+        id: string;
+    }): Promise<void>;
+    deleteMany(params: {
+        id: string;
+    }[]): Promise<number>;
+    deleteAll(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<NotionRepository<any>, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<NotionRepository<any>>;
+}
+
+type NotionText = {
+    type: 'text';
+    text: {
+        content: string;
+    };
+    plain_text: string;
+};
+type NotionArray = {
+    type: 'array';
+    array: (NotionRichText[] | NotionNumber[]);
+    function: 'show_original';
+};
+type NotionTitle = {
+    type: 'title';
+    title: {
+        text: {
+            content: string;
+        };
+    }[];
+};
+type NotionUrl = {
+    id: string;
+    type: 'url';
+    url: string | null;
+};
+type NotionRichText = {
+    id: string;
+    type: 'rich_text';
+    rich_text: NotionText[];
+};
+type NotionNumber = {
+    id: string;
+    type: 'number';
+    number: number;
+};
+type NotionRelation = {
+    id: string;
+    type: 'relation';
+    relation: {
+        id: string;
+    }[];
+    has_more: boolean;
+};
+type NotionStatus = {
+    id: string;
+    type: 'status';
+    status: {
+        id: string;
+        name: string;
+        color: string;
+    };
+};
+type NotionFormula = {
+    id: string;
+    type: 'formula';
+    formula: {
+        type: 'string';
+        string: string;
+    } | {
+        type: 'number';
+        number: number;
+    } | {
+        type: 'date';
+        date: {
+            start: string;
+            end: string;
+            time_zone: null;
+        };
+    };
+};
+type NotionRollup = {
+    id: string;
+    type: 'rollup';
+    rollup: NotionArray | NotionNumber;
+};
+type NotionCreatedTime = {
+    id: string;
+    type: 'created_time';
+    created_time: string;
+};
+type NotionLastEditedTime = {
+    id: string;
+    type: 'last_edited_time';
+    last_edited_time: string;
+};
+type NotionDate = {
+    id: string;
+    type: 'date';
+    date: any;
+};
+type NotionSelect = {
+    id: string;
+    type: 'select';
+    select: {
+        id: string;
+        name: string;
+        color: string;
+    };
+};
+type NotionPhoneNumber = {
+    id: string;
+    type: 'phone_number';
+    phone_number: string;
+};
+type NotionEmail = {
+    id: string;
+    type: 'email';
+    email: string;
+};
+type NotionID = {
+    id: string;
+    type: 'unique_id';
+    unique_id: {
+        prefix: string | null;
+        number: number;
+    };
+};
+type NotionValue = NotionTitle | NotionUrl | NotionRichText | NotionNumber | NotionRelation | NotionStatus | NotionFormula | NotionRollup | NotionCreatedTime | NotionLastEditedTime | NotionDate | NotionSelect | NotionPhoneNumber | NotionEmail | NotionID;
+declare class NotionUtils {
+    static toNotionValue(value: any, annotation: NotionAnnotation): void | {
+        type: string;
+        title: {
+            text: {
+                content: string;
+            };
+        }[];
+    } | {
+        type: string;
+        status: {
+            name: string;
+        };
+    } | {
+        type: string;
+        relation: {
+            id: string;
+        }[];
+    } | {
+        type: string;
+        rich_text: {
+            text: {
+                content: string;
+            };
+        }[];
+    } | {
+        type: string;
+        url: string;
+    } | {
+        type: string;
+        date: {
+            start: string;
+        };
+    } | {
+        type: string;
+        select: {
+            name: string;
+        };
+    } | {
+        type: string;
+        number: number;
+    } | {
+        type: string;
+        phone_number: string;
+    } | {
+        type: string;
+        email: string;
+    };
+    static toNotionTitle(value: string): {
+        type: string;
+        title: {
+            text: {
+                content: string;
+            };
+        }[];
+    };
+    static toNotionStatus(value: string): {
+        type: string;
+        status: {
+            name: string;
+        };
+    };
+    static toNotionRelationMulti(ids: string[]): {
+        type: string;
+        relation: {
+            id: string;
+        }[];
+    };
+    static toNotionRelation(value: string): {
+        type: string;
+        relation: {
+            id: string;
+        }[];
+    };
+    static toNotionRichText(text?: string): {
+        type: string;
+        rich_text: {
+            text: {
+                content: string;
+            };
+        }[];
+    };
+    static toNotionFormula(value: string): void;
+    static toNotionRollup(value: string): void;
+    static toNotionUrl(value: string): {
+        type: string;
+        url: string;
+    };
+    static toNotionDate(value: Date): {
+        type: string;
+        date: {
+            start: string;
+        };
+    };
+    static toNotionSelect(value: string): {
+        type: string;
+        select: {
+            name: string;
+        };
+    };
+    static toNotionPhoneNumber(value: string): {
+        type: string;
+        phone_number: string;
+    };
+    static toNotionNumber(value: number): {
+        type: string;
+        number: number;
+    };
+    static toNotionEmail(value: string): {
+        type: string;
+        email: string;
+    };
+    static fromNotionValue(value: NotionValue, annotation: NotionAnnotation): string | number | string[] | Date | dayjs.Dayjs | number[];
+    static fromNotionTitle(notionTitle: NotionTitle): string;
+    static fromNotionUrl(notionUrl: NotionUrl): string | null;
+    static fromNotionRichText(notionRichText: NotionRichText): string | null;
+    static fromNotionRelation(notionRelation: NotionRelation): string | null;
+    static fromNotionRelationMulti(notionRelation: NotionRelation): string[];
+    static fromNotionStatus(notionStatus: NotionStatus): string | null;
+    static fromNotionFormula(notionFormula: NotionFormula): string | number | Date;
+    static fromNotionRollup(notionRollup: NotionRollup): string | number;
+    static fromNotionRollupMulti(notionRollup: NotionRollup): string[] | number[];
+    static fromNotionCreatedTime(notionCreatedTime: NotionCreatedTime): dayjs.Dayjs;
+    static fromNotionLastEditedTime(notionLastEditedTime: NotionLastEditedTime): dayjs.Dayjs;
+    static fromNotionDate(notionDate: NotionDate): Date | null;
+    static fromNotionNumber(notionNumber: NotionNumber): number;
+    static fromNotionSelect(notionSelect: NotionSelect): string;
+    static fromNotionPhoneNumber(notionPhoneNumber: NotionPhoneNumber): string;
+    static fromNotionEmail(notionEmail: NotionEmail): string;
+    static fromNotionUniqueID(value: NotionID): number;
+}
+
+export { CreatedTime, Date$1 as Date, Email, Formula, LastEditedTime, N, NOTION_ACCESS_TOKEN, NOTION_ANNOTATIONS, NOTION_CONFIG, NOTION_DATABASE_ID, NOTION_SERVICE, Notion, NotionAnd, NotionBaseQuery, NotionConverter, NotionFilter, NotionHelper, NotionOr, NotionQueryBuilder, NotionRepository, NotionSort, NotionUtils, Number, PhoneNumber, Query, Relation, RichText, Rollup, Select, Status, Timestamp, Title, UniqueID, Url, createConverter, injectNotion, provideNotionConfig };
+export type { NotionAnnotation, NotionConfig, NotionCreatedTime, NotionDate, NotionEmail, NotionFieldType, NotionFormula, NotionID, NotionLastEditedTime, NotionNumber, NotionPhoneNumber, NotionRelation, NotionRichText, NotionRollup, NotionSelect, NotionStatus, NotionTitle, NotionUrl, NotionValue };

package/package.json

@@ -1,23 +1,29 @@
 {
   "name": "@nx-ddd/notion",
-  "version": "19.0.0-preview.9",
-  "main": "./index.js",
-  "types": "./index.d.ts",
-  "homepage": "https://github.com/xx-machina/plaform/tree/main/packages/@nx-ddd/notion",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/xx-machina/plaform.git"
-  },
+  "version": "19.1.1",
+  "license": "MIT",
   "peerDependencies": {
     "@notionhq/client": "^2.2.2",
-    "@nx-ddd/common": "19.0.0-preview.9",
+    "@nx-ddd/common": "19.1.1",
     "dayjs": "1.11.13",
     "lodash-es": "^4.17.15",
-    "tslib": "^2.3.0",
     "@angular/core": "19.1.4",
     "node-localstorage": "^3.0.5",
     "crypto-js": "4.2.0"
   },
-  "dependencies": {},
-  "type": "commonjs"
+  "dependencies": {
+    "tslib": "^2.3.0"
+  },
+  "module": "fesm2022/nx-ddd-notion.mjs",
+  "typings": "index.d.ts",
+  "exports": {
+    "./package.json": {
+      "default": "./package.json"
+    },
+    ".": {
+      "types": "./index.d.ts",
+      "default": "./fesm2022/nx-ddd-notion.mjs"
+    }
+  },
+  "sideEffects": false
 }

package/README.md

@@ -1,11 +0,0 @@
-# notion
-
-This library was generated with [Nx](https://nx.dev).
-
-## Running unit tests
-
-Run `nx test notion` to execute the unit tests via [Jest](https://jestjs.io).
-
-## Running lint
-
-Run `nx lint notion` to execute the lint via [ESLint](https://eslint.org/).

package/_testing/entity.d.ts

@@ -1,20 +0,0 @@
-import { NotionConverter } from '../converter';
-export declare class Entity {
-    title: string;
-    status: string;
-    firstSelectionIds: string[];
-    discordFirstSelectionMessage: string;
-    discordSecondSelectionMessage: string;
-    discordChannelId: string;
-    static from(obj: Partial<Entity>): Entity & {
-        title?: string;
-        status?: string;
-        firstSelectionIds?: string[];
-        discordFirstSelectionMessage?: string;
-        discordSecondSelectionMessage?: string;
-        discordChannelId?: string;
-    };
-}
-export declare class EntityConverter extends NotionConverter<Entity> {
-    protected Entity: typeof Entity;
-}