@xxmachina/common 19.0.0-preview.9 → 19.1.0

package/fesm2022/xxmachina-common-domain-builder.mjs

@@ -0,0 +1,494 @@
+import { createAction } from '@ng-atomic/core';
+import { flatten } from 'flat';
+import { omitBy } from 'lodash-es';
+import { createNavigateAction } from '@ng-atomic/components/frames/app';
+import { message } from '@nx-ddd/common';
+import { QueryHelper } from '@xxmachina/common/domain/models';
+
+class CommandBuilder {
+    buildFromOpenApi(openApi) {
+        return Object.keys(openApi.getPaths()).flatMap((path) => {
+            return openApi.getMethods(path).map((method, index) => ({
+                id: openApi.getOperationId(path, method) ?? `cmd-${index}`,
+                name: openApi.getSummary(path, method) ?? '',
+                description: openApi.getDescription(path, method) ?? '',
+                type: 'webApiRequest',
+                webApiRequest: {
+                    path: path,
+                    method: method.toLocaleUpperCase(),
+                    contentType: openApi.getContentType(path, method),
+                    responseContentType: openApi.getResponseContentType(path, method),
+                    bodySchema: openApi.getRequestBodySchema(path, method),
+                    serverUrl: openApi.getServerUrl(),
+                    apiJsonUrl: openApi.apiJsonUrl,
+                    security: openApi.getSecurity(path, method) ?? [],
+                }
+            }));
+        });
+    }
+}
+
+var ActionId;
+(function (ActionId) {
+    ActionId["NAVIGATE_TO_COMMAND_PAGE"] = "[@xxmachina/common] Navigate To Command Page";
+    ActionId["EXECUTE_COMMAND"] = "[@xxmachina/common] Execute Command";
+})(ActionId || (ActionId = {}));
+class CommandActionsBuilder {
+    commands = [];
+    options = {};
+    item = null;
+    filterIds = null;
+    autoIds = [];
+    setCommands(commands) {
+        const newFactory = new CommandActionsBuilder();
+        newFactory.commands = [...commands];
+        newFactory.options = { ...this.options };
+        newFactory.item = this.item;
+        newFactory.filterIds = this.filterIds;
+        newFactory.autoIds = this.autoIds;
+        return newFactory;
+    }
+    setOptions(options) {
+        const newFactory = new CommandActionsBuilder();
+        newFactory.commands = [...this.commands];
+        newFactory.options = { ...this.options, ...options };
+        newFactory.item = this.item;
+        newFactory.filterIds = this.filterIds;
+        newFactory.autoIds = this.autoIds;
+        return newFactory;
+    }
+    setItem(item) {
+        const newFactory = new CommandActionsBuilder();
+        newFactory.commands = [...this.commands];
+        newFactory.options = { ...this.options };
+        newFactory.item = item;
+        newFactory.filterIds = this.filterIds;
+        newFactory.autoIds = this.autoIds;
+        return newFactory;
+    }
+    setFilterIds(filterIds = []) {
+        const newFactory = new CommandActionsBuilder();
+        newFactory.commands = [...this.commands];
+        newFactory.options = { ...this.options };
+        newFactory.item = this.item;
+        newFactory.filterIds = filterIds.map((id) => typeof id === 'string' ? id : id.id);
+        newFactory.autoIds = filterIds.filter((id) => typeof id !== 'string' && id.auto).map((id) => id.id);
+        return newFactory;
+    }
+    setAutoIds(autoIds) {
+        const newFactory = new CommandActionsBuilder();
+        newFactory.commands = [...this.commands];
+        newFactory.options = { ...this.options };
+        newFactory.item = this.item;
+        newFactory.filterIds = [...this.filterIds];
+        newFactory.autoIds = autoIds;
+        return newFactory;
+    }
+    applyFilter(commands) {
+        if (!this.filterIds)
+            return commands;
+        return this.filterIds.map((id) => commands.find((command) => command.id === id))
+            .filter((command) => !!command);
+    }
+    buildAction(id) {
+        const command = this.commands.find((command) => command.id === id);
+        if (!command)
+            throw new Error(`Command not found: ${id}`);
+        const actionId = this.autoIds.includes(command.id)
+            ? ActionId.EXECUTE_COMMAND
+            : ActionId.NAVIGATE_TO_COMMAND_PAGE;
+        const creator = createAction(actionId, command.webApiRequest.bodySchema, {
+            name: command.name,
+            icon: this.options.icon || 'default',
+            ...this.options,
+        });
+        return creator.create({
+            command,
+            body: this.item,
+            options: {
+                queryId: this.options.queryId,
+                confirm: this.options.confirm,
+            }
+        });
+    }
+    buildActions(item, navigationExtras = {}, overwrite = {}) {
+        const filteredCommands = this.applyFilter(this.commands);
+        return filteredCommands.map((command) => {
+            if (this.autoIds.includes(command.id)) {
+                return createAction(ActionId.EXECUTE_COMMAND, command.webApiRequest.bodySchema, {
+                    name: command.name,
+                    icon: this.options.icon || 'default',
+                }).create({
+                    command,
+                    body: this.item,
+                    options: {
+                        queryId: this.options.queryId,
+                        confirm: this.options.confirm,
+                    }
+                }, overwrite);
+            }
+            else {
+                const data = omitBy(flatten({ data: this.item, queryId: this.options.queryId }), value => typeof value === 'undefined');
+                return createNavigateAction(['commands', { skip: true }, command.id, data], navigationExtras, {
+                    name: command.name,
+                    icon: this.options.icon,
+                    ...overwrite,
+                });
+            }
+        });
+    }
+    buildItemActions() {
+        return (item) => this.setItem(item).buildActions();
+    }
+}
+function createCommandNavigateAction(command, navigationExtras = {}, item = {}, options = {}, overwrite = {}) {
+    if (!command)
+        return null;
+    return new CommandActionsBuilder()
+        .setItem(item)
+        .setCommands([command])
+        .setOptions(options)
+        .setFilterIds([command.id])
+        .buildActions(item, navigationExtras, overwrite)[0];
+}
+function createCommandExecutionAction(command, item = {}, options = {}, overwrite = {}) {
+    if (!command)
+        return null;
+    return new CommandActionsBuilder()
+        .setItem(item)
+        .setCommands([command])
+        .setOptions(options)
+        .setFilterIds([command.id])
+        .setAutoIds([command.id])
+        .buildActions(item, undefined, overwrite)[0];
+}
+
+const NOTION_PROP_TYPE_MAP = {
+    people: 'string',
+    unique_id: 'string',
+    rich_text: 'string',
+    title: 'string',
+    text: 'string',
+    number: 'number',
+    select: 'enum',
+    status: 'enum',
+    multi_select: 'string',
+    date: 'date',
+    person: 'string',
+    files: 'string',
+    checkbox: 'boolean',
+    url: 'string',
+    email: 'string',
+    phone_number: 'string',
+    relation: 'string',
+    rollup: 'string',
+    created_time: 'date',
+    created_by: 'string',
+    last_edited_time: 'date',
+    last_edited_by: 'string',
+};
+const NOTION_KEY_MAP = {
+    'relation': 'FK',
+    'unique_id': 'UK',
+};
+class ErBuilder {
+    build(databases) {
+        const schemas = [];
+        const dbIdToName = databases.reduce((acc, db) => ({
+            ...acc,
+            [db.id]: db?.title?.[0]?.plain_text
+        }), {});
+        for (const database of databases) {
+            const schema = this.parseDatabaseSchema(database, database?.title?.[0]?.plain_text, dbIdToName);
+            schemas.push(schema);
+        }
+        return this.buildMermaidER(schemas);
+    }
+    parseDatabaseSchema(database, name = '', map = {}) {
+        const properties = database.properties;
+        const fields = [];
+        const relations = [];
+        Object.keys(properties)
+            .filter(propName => {
+            if (['formula', 'rollup', 'button'].includes(properties[propName].type))
+                return false;
+            return true;
+        })
+            .sort()
+            .forEach(propName => {
+            const prop = properties[propName];
+            const type = prop.type;
+            const mappedType = NOTION_PROP_TYPE_MAP[type];
+            const key = NOTION_KEY_MAP[type] ?? ' ';
+            const field = `${mappedType} ${type} ${key} "${propName}"`;
+            fields.push(field);
+            // リレーションシップの解析
+            if (type === 'relation') {
+                const relation = prop['relation'];
+                if (relation && relation.database_id) {
+                    const targetDbId = relation.database_id;
+                    const targetDbName = map[targetDbId] || 'Unknown';
+                    relations.push({
+                        source: name,
+                        target: targetDbName,
+                        label: propName,
+                        type: '||--||', // リレーションのタイプを適宜設定
+                    });
+                }
+                else if (relation && Array.isArray(relation)) {
+                    relation.forEach(rel => {
+                        const targetDbId = rel.database_id;
+                        const targetDbName = map[targetDbId] || 'Unknown';
+                        relations.push({
+                            source: name,
+                            target: targetDbName,
+                            label: propName,
+                            type: '||--o{',
+                        });
+                    });
+                }
+            }
+        });
+        return { name, fields, relations };
+    }
+    buildMermaidER(schemas) {
+        let mermaid = 'erDiagram\n';
+        // エンティティの定義
+        schemas.forEach(schema => {
+            mermaid += `  "${schema.name}" {\n`;
+            mermaid += schema.fields.map(field => `    ${field}`).join('\n');
+            mermaid += '\n  }\n';
+        });
+        // リレーションシップの定義
+        schemas.forEach(schema => {
+            schema.relations.forEach(relation => {
+                mermaid += `  "${relation.source}" ${relation.type} "${relation.target}" : "${relation.label}"\n`;
+            });
+        });
+        return mermaid;
+    }
+}
+
+class QueryBuilder {
+    static buildByGraphql(graphql, meta = {}) {
+        return QueryHelper.tryParse({
+            id: 'builded_query',
+            type: 'graphql',
+            projectId: 'default',
+            title: 'Builded Query',
+            summary: 'This query was built by QueryBuilder',
+            graphql: {
+                endpoint: graphql.endpoint,
+                query: message `${graphql.query}`,
+                headersJson: JSON.stringify(graphql.headers),
+                variablesJson: JSON.stringify(graphql.variables),
+                transformerTs: graphql?.transformerTs ?? null,
+            },
+            createdAt: null,
+            updatedAt: null,
+            ...meta,
+        });
+    }
+}
+
+function buildPageItem(property, propName, dbName) {
+    switch (property.type) {
+        case 'select': return {
+            id: property.id,
+            name: propName,
+            type: '入力(単一選択)',
+            notionPropType: 'セレクト',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'multi_select': return {
+            id: property.id,
+            name: propName,
+            type: '入力(複数選択)',
+            notionPropType: 'マルチセレクト',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'relation': return {
+            id: property.id,
+            name: propName,
+            type: '入力(単一選択)',
+            notionPropType: 'リレーション',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'rollup': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: 'ロールアップ',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'unique_id': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: 'ユニークID',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'created_time': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: '作成日時',
+            formula: '',
+            valueType: 'date',
+            dbName,
+        };
+        case 'created_by': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: '作成者',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'rich_text': return {
+            id: property.id,
+            name: propName,
+            type: '入力(テキスト)',
+            notionPropType: 'テキスト',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'number': return {
+            id: property.id,
+            name: propName,
+            type: '入力(数値)',
+            notionPropType: '数値',
+            formula: '',
+            valueType: 'number',
+            dbName,
+        };
+        case 'date': return {
+            id: property.id,
+            name: propName,
+            type: '入力(日時)',
+            notionPropType: '日時',
+            formula: '',
+            valueType: 'date',
+            dbName,
+        };
+        case 'checkbox': return {
+            id: property.id,
+            name: propName,
+            type: '入力(複数選択)',
+            notionPropType: 'チェックボックス',
+            formula: '',
+            valueType: 'boolean',
+            dbName,
+        };
+        case 'title': return {
+            id: property.id,
+            name: propName,
+            type: '入力(テキスト)',
+            notionPropType: 'タイトル',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'people': return {
+            id: property.id,
+            name: propName,
+            type: '入力(単一選択)',
+            notionPropType: 'ユーザー',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'last_edited_time': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: '最終更新日時',
+            formula: '',
+            valueType: 'date',
+            dbName,
+        };
+        case 'last_edited_by': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: '最終更新者',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'status': return {
+            id: property.id,
+            name: propName,
+            type: '入力(単一選択)',
+            notionPropType: 'ステータス',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        case 'formula': return {
+            id: property.id,
+            name: propName,
+            type: '表示',
+            notionPropType: '数式',
+            formula: '',
+            valueType: 'any',
+            dbName,
+        };
+        /* @ts-ignore */
+        case 'button': return {
+            id: property?.['id'] ?? '',
+            name: propName,
+            type: 'ボタン',
+            notionPropType: 'ボタン',
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+        default: return {
+            id: property.id,
+            name: propName,
+            type: '不明',
+            notionPropType: property.type,
+            formula: '',
+            valueType: 'string',
+            dbName,
+        };
+    }
+}
+class ScreenItemBuilder {
+    build(database) {
+        const items = [];
+        Object.entries(database?.properties ?? {}).sort((a, b) => {
+            return a[0].localeCompare(b[0]);
+        }).filter(([propName, prop]) => {
+            // if (propName.startsWith('_')) return false;
+            // if (/^\d/.test(propName)) return false;
+            // if (propName.includes('旧エクセル')) return false;
+            // if (['formula', 'rollup', 'button'].includes(prop.type)) return false;
+            return true;
+        }).forEach(([propName, prop]) => {
+            const item = buildPageItem(prop, propName, database?.title?.[0]?.plain_text ?? '');
+            items.push(item);
+        });
+        return items;
+    }
+}
+
+/**
+ * Generated bundle index. Do not edit.
+ */
+
+export { ActionId, CommandActionsBuilder, CommandBuilder, ErBuilder, QueryBuilder, ScreenItemBuilder, createCommandExecutionAction, createCommandNavigateAction };
+//# sourceMappingURL=xxmachina-common-domain-builder.mjs.map