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

package/fesm2022/nx-ddd-notion.mjs

@@ -0,0 +1,540 @@
+import dayjs from 'dayjs';
+import { omitBy } from 'lodash-es';
+import * as i0 from '@angular/core';
+import { InjectionToken, inject, Injectable } from '@angular/core';
+import { Client } from '@notionhq/client';
+import { Repository } from '@nx-ddd/common/domain';
+
+//  | NotionCheckbox;
+class NotionUtils {
+    static toNotionValue(value, annotation) {
+        switch (annotation.type) {
+            case 'title': return this.toNotionTitle(value);
+            case 'status': return this.toNotionStatus(value);
+            case 'relation':
+                if (annotation.options.multi) {
+                    return this.toNotionRelationMulti(value);
+                }
+                else {
+                    return this.toNotionRelation(value);
+                }
+            case 'formula': return this.toNotionFormula(value);
+            case 'rich_text': return this.toNotionRichText(value);
+            case 'rollup': return this.toNotionRollup(value);
+            case 'url': return this.toNotionUrl(value);
+            case 'date': return this.toNotionDate(value);
+            case 'select': return this.toNotionSelect(value);
+            case 'number': return this.toNotionNumber(value);
+            case 'phone_number': return this.toNotionPhoneNumber(value);
+            case 'email': return this.toNotionEmail(value);
+        }
+    }
+    static toNotionTitle(value) {
+        return value ? { type: 'title', title: [{ text: { content: value } }] } : undefined;
+    }
+    static toNotionStatus(value) {
+        return value ? { type: 'status', status: { name: value } } : undefined;
+    }
+    static toNotionRelationMulti(ids) {
+        return Array.isArray(ids) ? { type: 'relation', relation: (ids).map(id => ({ id })) } : undefined;
+    }
+    static toNotionRelation(value) {
+        return value ? this.toNotionRelationMulti([value]) : undefined;
+    }
+    static toNotionRichText(text) {
+        return text ? { type: 'rich_text', rich_text: [{ text: { content: text } }] } : undefined;
+    }
+    static toNotionFormula(value) {
+        return;
+    }
+    static toNotionRollup(value) {
+        return;
+    }
+    static toNotionUrl(value) {
+        return value ? { type: 'url', url: value } : undefined;
+    }
+    static toNotionDate(value) {
+        // TODO(nontangent): endも考慮する。
+        return value ? { type: 'date', date: { start: dayjs(value).format() } } : undefined;
+    }
+    static toNotionSelect(value) {
+        return value ? { type: 'select', select: { name: value } } : undefined;
+    }
+    static toNotionPhoneNumber(value) {
+        return value ? { type: 'phone_number', phone_number: value } : undefined;
+    }
+    static toNotionNumber(value) {
+        return value ? { type: 'number', number: value } : undefined;
+    }
+    static toNotionEmail(value) {
+        return value ? { type: 'email', email: value } : undefined;
+    }
+    static fromNotionValue(value, annotation) {
+        switch (value.type) {
+            case 'title': return this.fromNotionTitle(value);
+            case 'formula': return this.fromNotionFormula(value);
+            case 'relation':
+                if (annotation.options.multi) {
+                    return this.fromNotionRelationMulti(value);
+                }
+                else {
+                    return this.fromNotionRelation(value);
+                }
+            case 'rich_text': return this.fromNotionRichText(value);
+            case 'status': return this.fromNotionStatus(value);
+            case 'url': return this.fromNotionUrl(value);
+            case 'rollup':
+                if (annotation.options.multi) {
+                    return this.fromNotionRollupMulti(value);
+                }
+                else {
+                    return this.fromNotionRollup(value);
+                }
+            case 'created_time': return this.fromNotionCreatedTime(value);
+            case 'last_edited_time': return this.fromNotionLastEditedTime(value);
+            case 'date': return this.fromNotionDate(value);
+            case 'number': return this.fromNotionNumber(value);
+            case 'select': return this.fromNotionSelect(value);
+            case 'phone_number': return this.fromNotionPhoneNumber(value);
+            case 'email': return this.fromNotionEmail(value);
+            case 'unique_id': return this.fromNotionUniqueID(value);
+        }
+    }
+    static fromNotionTitle(notionTitle) {
+        return notionTitle?.title?.[0]?.text?.content ?? '';
+    }
+    static fromNotionUrl(notionUrl) {
+        return notionUrl.url;
+    }
+    static fromNotionRichText(notionRichText) {
+        return notionRichText.rich_text.map(({ plain_text }) => plain_text).join('') || null;
+    }
+    static fromNotionRelation(notionRelation) {
+        return this.fromNotionRelationMulti(notionRelation)?.[0] ?? null;
+    }
+    static fromNotionRelationMulti(notionRelation) {
+        return notionRelation.relation.map(r => r.id);
+    }
+    static fromNotionStatus(notionStatus) {
+        return notionStatus.status?.name ?? null;
+    }
+    static fromNotionFormula(notionFormula) {
+        switch (notionFormula.formula?.type) {
+            case 'string': return notionFormula.formula.string;
+            case 'number': return notionFormula.formula.number;
+            case 'date': return this.fromNotionDate(notionFormula.formula);
+        }
+    }
+    static fromNotionRollup(notionRollup) {
+        if (notionRollup.rollup.type === 'number') {
+            return this.fromNotionNumber(notionRollup.rollup);
+        }
+        return this.fromNotionRollupMulti(notionRollup)?.[0] ?? null;
+    }
+    static fromNotionRollupMulti(notionRollup) {
+        if (notionRollup.rollup.type === 'number') {
+            return [];
+        }
+        return (notionRollup.rollup.array ?? []).map(notionValue => {
+            if (notionValue.type === 'rich_text') {
+                return (notionValue.rich_text ?? []).map(text => text.plain_text).join();
+            }
+            else if (notionValue.type === 'number') {
+                return notionValue.number ?? null;
+            }
+            return [];
+        });
+    }
+    static fromNotionCreatedTime(notionCreatedTime) {
+        return dayjs(notionCreatedTime.created_time);
+    }
+    static fromNotionLastEditedTime(notionLastEditedTime) {
+        return dayjs(notionLastEditedTime.last_edited_time);
+    }
+    static fromNotionDate(notionDate) {
+        return notionDate.date?.start ? dayjs(notionDate.date?.start).toDate() : null;
+    }
+    static fromNotionNumber(notionNumber) {
+        return notionNumber.number ?? null;
+    }
+    static fromNotionSelect(notionSelect) {
+        return notionSelect.select?.name ?? null;
+    }
+    static fromNotionPhoneNumber(notionPhoneNumber) {
+        return notionPhoneNumber.phone_number ?? null;
+    }
+    static fromNotionEmail(notionEmail) {
+        return notionEmail.email ?? null;
+    }
+    static fromNotionUniqueID(value) {
+        return value.unique_id.number;
+    }
+}
+
+const NOTION_ANNOTATIONS = 'notion_annotations';
+function createDecorator(type, defaultOptions) {
+    return (name, options) => {
+        return (target, propName) => {
+            const fieldName = name || propName;
+            const ANNOTATION = { type, fieldName, propName, options: { ...defaultOptions, ...options } };
+            target.constructor[NOTION_ANNOTATIONS] ??= [];
+            target.constructor[NOTION_ANNOTATIONS].push(ANNOTATION);
+        };
+    };
+}
+const Title = createDecorator('title');
+const Url = createDecorator('url');
+const RichText = createDecorator('rich_text');
+const Relation = createDecorator('relation', { multi: false });
+const Status = createDecorator('status');
+const Formula = createDecorator('formula');
+const Rollup = createDecorator('rollup', { multi: false });
+const Timestamp = createDecorator('timestamp');
+const Number = createDecorator('number');
+const CreatedTime = createDecorator('created_time');
+const LastEditedTime = createDecorator('last_edited_time');
+const Date = createDecorator('date');
+const Select = createDecorator('select');
+const PhoneNumber = createDecorator('phone_number');
+const Email = createDecorator('email');
+const UniqueID = createDecorator('unique_id');
+// Not implemented below props!
+// export const Checkbox = createDecorator('checkbox');
+// export const CreatedBy = createDecorator('created_by');
+// export const Files = createDecorator('files');
+// export const LastEditedBy = createDecorator('last_edited_by');
+// export const MultiSelect = createDecorator('multi_select');
+// export const People = createDecorator('people');
+const Notion = {
+    Title,
+    Url,
+    RichText,
+    Relation,
+    Status,
+    Formula,
+    Rollup,
+    Timestamp,
+    Number,
+    CreatedTime,
+    LastEditedTime,
+    Date,
+    Select,
+    PhoneNumber,
+    Email,
+    UniqueID,
+};
+
+class NotionHelper {
+    static fromNotion(page, Entity) {
+        const annotations = Entity[NOTION_ANNOTATIONS] ?? [];
+        const obj = annotations.reduce((obj, annotation) => {
+            const value = page['properties'][annotation.fieldName]
+                ? NotionUtils.fromNotionValue(page['properties'][annotation.fieldName], annotation)
+                : undefined;
+            return { ...obj, [annotation.propName]: value };
+        }, { id: page.id });
+        return Entity.from(obj);
+    }
+    static toNotion(entity, Entity) {
+        const annotations = Entity[NOTION_ANNOTATIONS] ?? [];
+        const data = annotations.reduce((obj, annotation) => ({
+            ...obj,
+            [annotation.fieldName]: NotionUtils.toNotionValue(entity[annotation.propName], annotation),
+        }), {});
+        return omitBy(data, (value) => typeof value === 'undefined');
+    }
+}
+class NotionConverter {
+    fromNotion(page) {
+        return NotionHelper.fromNotion(page, this.Entity);
+    }
+    toNotion(entity) {
+        return NotionHelper.toNotion(entity, this.Entity);
+    }
+}
+function createConverter(Entity) {
+    class Converter extends NotionConverter {
+        Entity = Entity;
+    }
+    return new Converter();
+}
+
+const NOTION_SERVICE = new InjectionToken('NOTION_SERVICE');
+const NOTION_CONFIG = new InjectionToken('NOTION_CONFIG');
+function injectNotion() {
+    return inject(NOTION_SERVICE, { optional: true }) ?? null;
+}
+
+class N {
+    static RollupPropQuery(property, evaluation, value) {
+        return { property, rollup: { every: { rich_text: { equals: value } } } };
+    }
+    static FormulaQuery(property, evaluation, value) {
+        return { property, formula: {} };
+    }
+    static LastEditedTime(property, evaluation, value) {
+        const query = evaluation === '>' ? 'after'
+            : evaluation === '<' ? 'before'
+                : evaluation === '==' ? 'equals'
+                    : evaluation === '<=' ? 'on_or_before'
+                        : evaluation === '>=' ? 'on_or_after'
+                            : evaluation === '!=' ? '' : '';
+        return { timestamp: 'last_edited_time', last_edited_time: { [query]: value } };
+    }
+    static Timestamp(property, evaluation, value) {
+        const query = evaluation === '>' ? 'after'
+            : evaluation === '<' ? 'before'
+                : evaluation === '==' ? 'equals'
+                    : evaluation === '<=' ? 'on_or_before'
+                        : evaluation === '>=' ? 'on_or_after'
+                            : evaluation === '!=' ? '' : '';
+        return { property, timestamp: { [query]: value } };
+    }
+    static Status(property, evaluation, value) {
+        const query = evaluation === '==' ? 'equals' : '';
+        // TODO(nontangent): 'ステータス'を修正
+        return { property: 'ステータス', status: { [query]: value } };
+    }
+    static Relation(property, evaluation, value) {
+        const query = evaluation === 'in' ? 'contains' : '';
+        return { property, relation: { [query]: value } };
+    }
+}
+class NotionBaseQuery {
+    type;
+}
+class NotionFilter extends NotionBaseQuery {
+    propertyType;
+    propertyName;
+    evaluation;
+    value;
+    type = 'filter';
+    constructor(propertyType, propertyName, evaluation, value) {
+        super();
+        this.propertyType = propertyType;
+        this.propertyName = propertyName;
+        this.evaluation = evaluation;
+        this.value = value;
+    }
+    build() {
+        switch (this.propertyName) {
+            case 'last_edited_time': return N.LastEditedTime(this.propertyName, this.evaluation, this.value);
+        }
+        switch (this.propertyType) {
+            case 'rollup': return N.RollupPropQuery(this.propertyName, this.evaluation, this.value);
+            case 'formula': return N.FormulaQuery(this.propertyName, this.evaluation, this.value);
+            case 'status': return N.Status(this.propertyName, this.evaluation, this.value);
+            case 'relation': return N.Relation(this.propertyName, this.evaluation, this.value);
+        }
+    }
+}
+class NotionSort extends NotionBaseQuery {
+    property;
+    direction;
+    type = 'sort';
+    constructor(property, direction = 'asc') {
+        super();
+        this.property = property;
+        this.direction = direction;
+    }
+    build() {
+        return {
+            property: this.property,
+            direction: this.direction === 'asc' ? 'ascending' : 'descending',
+        };
+    }
+}
+class NotionAnd extends NotionBaseQuery {
+    type = 'and';
+    arr;
+    constructor(...filters) {
+        super();
+        this.arr = filters;
+    }
+    build() {
+        return { and: this.arr.map(filter => filter.build()) };
+    }
+}
+class NotionOr extends NotionBaseQuery {
+    type = 'or';
+    arr;
+    constructor(...filters) {
+        super();
+        this.arr = filters;
+    }
+    build() {
+        return { or: this.arr.map(filter => filter.build()) };
+    }
+}
+const Query = (Entity) => {
+    const Filter = (_propName, evaluation, value) => {
+        const annotation = Entity[NOTION_ANNOTATIONS].find(({ propName }) => propName === _propName);
+        // if(!annotation) {
+        //   throw new Error(`NotionFilter: ${Entity} does not have ${_propName}.`);
+        // }
+        return new NotionFilter(annotation?.type, annotation?.fieldName ?? _propName, evaluation, value);
+    };
+    const OrderBy = (_propName, direction) => {
+        const annotation = Entity[NOTION_ANNOTATIONS].find(({ propName }) => propName === _propName);
+        return new NotionSort(annotation?.fieldName ?? _propName, direction);
+    };
+    const And = (...args) => new NotionAnd(...args);
+    const Or = (...args) => new NotionOr(...args);
+    return { Filter, OrderBy, And, Or };
+};
+
+class NotionQueryBuilder {
+    constructor() { }
+    build(filterQuery, sortQuery) {
+        return {
+            ...(filterQuery ? this.buildFilterQuery(filterQuery) : {}),
+            ...(sortQuery ? this.buildSortQuery(sortQuery) : {}),
+        };
+    }
+    buildSortQuery(query) {
+        if (query.type === 'sort') {
+            return { sorts: [query.build()] };
+        }
+        else {
+            return {};
+        }
+    }
+    buildFilterQuery(query) {
+        if (query.type === 'filter') {
+            return { filter: { and: [query.build()] } };
+        }
+        else if (['and', 'or'].includes(query.type)) {
+            return { filter: query.build() };
+        }
+        else {
+            return {};
+        }
+    }
+}
+
+const NOTION_ACCESS_TOKEN = new InjectionToken('[@nx-ddd/notion] Notion Access Token');
+const NOTION_DATABASE_ID = new InjectionToken('[@nx-ddd/notion] Notion Database Id');
+function provideNotionConfig(config) {
+    return { provide: NOTION_ACCESS_TOKEN, useValue: config.accessToken };
+}
+class NotionRepository extends Repository {
+    token = inject(NOTION_ACCESS_TOKEN);
+    client = new Client({ auth: this.token });
+    queryBuilder = new NotionQueryBuilder();
+    get parent() {
+        return { type: 'database_id', database_id: this.databaseId };
+    }
+    async query(filterQuery, sortQuery, startCursor, pageSize) {
+        try {
+            const obj = this.queryBuilder.build(filterQuery, sortQuery);
+            const res = await this.client.databases.query({
+                database_id: this.databaseId,
+                ...obj,
+                start_cursor: startCursor,
+                page_size: pageSize,
+            });
+            return {
+                results: res.results.map(result => this.converter.fromNotion(result)),
+                nextCursor: res.next_cursor,
+                hasMore: res.has_more,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async queryV2(args) {
+        try {
+            const res = await this.client.databases.query({
+                database_id: this.databaseId,
+                ...(args ?? {}),
+            });
+            return {
+                results: res.results.map(result => this.converter.fromNotion(result)),
+                nextCursor: res.next_cursor,
+                hasMore: res.has_more,
+            };
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async list({ batchSize = 100, } = {}) {
+        const items = [];
+        let nextCursor;
+        let pageCount = 0;
+        console.log(`[NotionRepository] Starting pagination with batch size: ${batchSize}`);
+        // eslint-disable-next-line no-constant-condition
+        while (true) {
+            pageCount++;
+            const res = await this.query(undefined, undefined, nextCursor, batchSize);
+            console.log(`[NotionRepository] Page ${pageCount}: Retrieved ${res.results.length} items, hasMore: ${res.hasMore}, nextCursor: ${res.nextCursor ? 'present' : 'null'}`);
+            items.push(...res.results);
+            nextCursor = res.nextCursor;
+            if (!res.hasMore) {
+                console.log(`[NotionRepository] Pagination complete. Total items: ${items.length} from ${pageCount} pages`);
+                break;
+            }
+        }
+        return items;
+    }
+    listChanges() {
+        throw new Error('NotionRepository.listChanges() is not implemented');
+    }
+    async get({ id }) {
+        const data = await this.client.pages.retrieve({ page_id: id });
+        return this.converter.fromNotion(data);
+    }
+    async create(entity) {
+        try {
+            const res = await this.client.pages.create({
+                parent: this.parent,
+                properties: { ...this.converter.toNotion(entity) },
+            });
+            return this.converter.fromNotion(res);
+        }
+        catch (error) {
+            throw error;
+        }
+    }
+    async createMany(data) {
+        throw new Error('NotionRepository.createMany() is not implemented');
+    }
+    async update(entity) {
+        const data = {
+            page_id: entity.id,
+            properties: { ...this.converter.toNotion(entity) },
+        };
+        await this.client.pages.update(data);
+    }
+    async save(data) {
+        throw new Error('NotionRepository.save() is not implemented');
+    }
+    async saveMany(entities) {
+        throw new Error('NotionRepository.saveMany() is not implemented');
+    }
+    async updateMany(data) {
+        throw new Error('NotionRepository.updateMany() is not implemented');
+    }
+    async delete({ id }) {
+        throw new Error('NotionRepository.delete() is not implemented');
+    }
+    async deleteMany(params) {
+        throw new Error('NotionRepository.deleteMany() is not implemented');
+    }
+    async deleteAll() {
+        throw new Error('NotionRepository.deleteAll() is not implemented');
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NotionRepository, deps: null, target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NotionRepository });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.0.5", ngImport: i0, type: NotionRepository, decorators: [{
+            type: Injectable
+        }] });
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { CreatedTime, 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 };
+//# sourceMappingURL=nx-ddd-notion.mjs.map