weaver-work-cli 0.1.6 → 0.1.7

package/dist/shortcuts/project/operations/types.js

@@ -0,0 +1,39 @@
+export function projectSuccess(action, data, meta) {
+    const payload = { ok: true, action, data };
+    if (meta && Object.keys(meta).length > 0)
+        payload.meta = meta;
+    return payload;
+}
+export function schemaOf(properties, options = {}) {
+    return {
+        type: 'object',
+        additionalProperties: false,
+        properties,
+        ...(options.required?.length ? { required: options.required } : {}),
+        ...(options.oneOf?.length ? { oneOf: options.oneOf } : {}),
+        ...(options.anyOf?.length ? { anyOf: options.anyOf } : {}),
+        ...(options.description ? { description: options.description } : {}),
+    };
+}
+export const SCHEMA_ID_STRING = { type: 'string', minLength: 1, pattern: '^\\d+$' };
+export const SCHEMA_PAGE_NO = { type: 'integer', minimum: 1, default: 1 };
+export const SCHEMA_PAGE_SIZE = { type: 'integer', minimum: 1, maximum: 1000, default: 10 };
+export const SCHEMA_FILTERS = {
+    type: 'object',
+    additionalProperties: true,
+    description: '源接口 mainTable 过滤字段。仅传用户明确指定的字段；空字符串会被视为未指定。',
+};
+export const SCHEMA_FIELDS = {
+    type: 'object',
+    additionalProperties: true,
+    description: '源接口 mainTable 字段。字段名和取值必须先按模块 reference 完成名称到 ID 的解析。',
+};
+export const SCHEMA_RECORDS = {
+    type: 'array',
+    minItems: 1,
+    maxItems: 100,
+    items: SCHEMA_FIELDS,
+    description: '待写入记录，最多 100 条，总大小不得超过 10M。',
+};
+export const SCHEMA_CONFIRM = { const: true, description: '必须为 true，表示用户已明确确认本次写入。' };
+export const SCHEMA_CONTINUATION = { type: 'string', minLength: 1, description: 'prepare 返回的 continuation，必须原样传入。' };

package/dist/shortcuts/project/operations/write.js

@@ -0,0 +1,266 @@
+import { projectPartialError, projectValidationError } from '../errors.js';
+import { assertDatajsonSuccess } from '../host.js';
+import { SCHEMA_CONFIRM, SCHEMA_CONTINUATION, SCHEMA_FIELDS, SCHEMA_ID_STRING, SCHEMA_RECORDS, projectSuccess, schemaOf, } from './types.js';
+import { asObject, idString, operatorId, stableFingerprint } from './shared.js';
+const WRITE_TARGETS = {
+    taskCreate: { entity: 'task', action: 'create', listPath: '', detailPath: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail', writePath: '/api/ebuilder/form/formdata/v2/saveFormData/createTask' },
+    taskUpdate: { entity: 'task', action: 'update', listPath: '', detailPath: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail', writePath: '/api/ebuilder/form/formdata/v2/updateFormData/updateTask' },
+    taskDelete: { entity: 'task', action: 'delete', listPath: '', detailPath: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryTaskDetail', writePath: '/api/ebuilder/form/formdata/v2/deleteFormData/deleteTask' },
+    projectCreate: { entity: 'project', action: 'create', listPath: '', detailPath: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail', writePath: '/api/ebuilder/form/formdata/v2/saveFormData/createProject' },
+    projectUpdate: { entity: 'project', action: 'update', listPath: '', detailPath: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail', writePath: '/api/ebuilder/form/formdata/v2/updateFormData/updateProject' },
+    projectDelete: { entity: 'project', action: 'delete', listPath: '', detailPath: '/api/ebuilder/form/formdata/v2/getFormDataByPk/queryProjDetail', writePath: '/api/ebuilder/form/formdata/v2/deleteFormData/deleteProject' },
+};
+function resolveManager(value, operator) {
+    return value === undefined || value === null || value === '' || value === '@me' ? operator : value;
+}
+function records(value) {
+    if (!Array.isArray(value) || value.length < 1 || value.length > 100) {
+        throw projectValidationError('records_invalid', 'records 必须是 1-100 条记录数组');
+    }
+    return value.map((item, index) => {
+        const record = asObject(item, `records[${index}]`);
+        if (Object.keys(record).length === 0) {
+            throw projectValidationError('records_invalid', `records[${index}] 不能为空对象`);
+        }
+        return record;
+    });
+}
+async function detail(host, target, id, operation) {
+    const response = await host.request({
+        method: 'POST',
+        path: target.detailPath,
+        body: {
+            datajson: JSON.stringify({
+                mainTable: { id },
+                header: { operator: await operatorId(host) },
+            }),
+        },
+        operation,
+    });
+    assertDatajsonSuccess(response, operation);
+    return response?.datajson ?? null;
+}
+async function sendWrite(host, operation, path, datajsonObject) {
+    let response;
+    try {
+        response = await host.request({
+            method: 'POST',
+            path,
+            body: { datajson: datajsonObject },
+            operation,
+        });
+    }
+    catch (error) {
+        if (error?.type === 'network') {
+            throw projectPartialError('写入请求已发出但结果不确定，请勿自动重试；先执行只读回查确认结果', {
+                operation,
+                path,
+            }, error.details);
+        }
+        throw error;
+    }
+    assertDatajsonSuccess(response, operation);
+    return response?.datajson ?? null;
+}
+async function verifySession(env, continuation) {
+    if (continuation.userId !== await operatorId(env.host)) {
+        throw projectValidationError('continuation_mismatch', 'continuation 与当前登录会话不匹配');
+    }
+}
+function createOperations(namePrefix, target) {
+    const prepareName = `${namePrefix}.prepare`;
+    const applyName = `${namePrefix}.apply`;
+    return [
+        {
+            name: prepareName,
+            resource: 'project',
+            method: 'write.prepare',
+            action: prepareName,
+            summary: `预览并生成${target.entity === 'task' ? '任务' : '项目'}创建写入 continuation，不发生写入`,
+            risk: 'read-before-write',
+            inputSchema: schemaOf({ records: SCHEMA_RECORDS }, { required: ['records'] }),
+            handler: async (args, env) => {
+                const operator = await operatorId(env.host);
+                const datajson = {
+                    header: { operator },
+                    operationinfo: {},
+                    datas: records(args.records).map((mainTable) => ({
+                        mainTable: { ...mainTable, manager: resolveManager(mainTable.manager, operator) },
+                    })),
+                };
+                const continuation = await env.continuation.issue({
+                    operation: applyName,
+                    userId: datajson.header.operator,
+                    datajson,
+                });
+                return projectSuccess(prepareName, {
+                    continuation,
+                    request: { datajson },
+                    recordCount: datajson.datas.length,
+                }, { requiresConfirmation: true });
+            },
+        },
+        {
+            name: applyName,
+            resource: 'project',
+            method: 'write.apply',
+            action: applyName,
+            summary: `经用户确认后创建${target.entity === 'task' ? '任务' : '项目'}`,
+            risk: 'high-risk-write',
+            requiresConfirmation: true,
+            inputSchema: schemaOf({
+                continuation: SCHEMA_CONTINUATION,
+                confirm: SCHEMA_CONFIRM,
+            }, { required: ['continuation', 'confirm'] }),
+            handler: async (args, env) => {
+                if (args.confirm !== true)
+                    throw projectValidationError('confirm_required', 'confirm 必须为 true');
+                const continuation = await env.continuation.verify(String(args.continuation), applyName);
+                await verifySession(env, continuation);
+                const datajson = asObject(continuation.datajson, 'continuation.datajson');
+                const response = await sendWrite(env.host, applyName, target.writePath, datajson);
+                return projectSuccess(applyName, response, { targetType: target.entity, writeAction: 'create' });
+            },
+        },
+    ];
+}
+function updateOperations(namePrefix, target) {
+    const prepareName = `${namePrefix}.prepare`;
+    const applyName = `${namePrefix}.apply`;
+    return [
+        {
+            name: prepareName,
+            resource: 'project',
+            method: 'write.prepare',
+            action: prepareName,
+            summary: `回查并预览${target.entity === 'task' ? '任务' : '项目'}更新，生成 continuation，不发生写入`,
+            risk: 'read-before-write',
+            inputSchema: schemaOf({ id: SCHEMA_ID_STRING, fields: SCHEMA_FIELDS }, { required: ['id', 'fields'] }),
+            handler: async (args, env) => {
+                const id = idString(args.id, 'id');
+                const fields = asObject(args.fields, 'fields');
+                if (Object.keys(fields).length === 0) {
+                    throw projectValidationError('fields_required', 'fields 至少包含一个要更新的字段');
+                }
+                const operator = await operatorId(env.host);
+                if (fields.manager === '@me')
+                    fields.manager = operator;
+                const current = await detail(env.host, target, id, `${namePrefix}.prepare`);
+                const datajson = {
+                    header: { operator },
+                    operationinfo: {},
+                    datas: [{ mainTable: { id, ...fields } }],
+                };
+                const continuation = await env.continuation.issue({
+                    operation: applyName,
+                    userId: datajson.header.operator,
+                    id,
+                    fingerprint: stableFingerprint(current),
+                    datajson,
+                });
+                return projectSuccess(prepareName, {
+                    continuation,
+                    request: { datajson },
+                    current,
+                }, { requiresConfirmation: true, id });
+            },
+        },
+        {
+            name: applyName,
+            resource: 'project',
+            method: 'write.apply',
+            action: applyName,
+            summary: `经用户确认并确认目标未变化后更新${target.entity === 'task' ? '任务' : '项目'}`,
+            risk: 'high-risk-write',
+            requiresConfirmation: true,
+            inputSchema: schemaOf({
+                continuation: SCHEMA_CONTINUATION,
+                confirm: SCHEMA_CONFIRM,
+            }, { required: ['continuation', 'confirm'] }),
+            handler: async (args, env) => {
+                if (args.confirm !== true)
+                    throw projectValidationError('confirm_required', 'confirm 必须为 true');
+                const continuation = await env.continuation.verify(String(args.continuation), applyName);
+                await verifySession(env, continuation);
+                const id = idString(continuation.id, 'continuation.id');
+                const current = await detail(env.host, target, id, applyName);
+                if (stableFingerprint(current) !== continuation.fingerprint) {
+                    throw projectValidationError('target_changed', '目标数据在确认后已变化，请重新执行 prepare');
+                }
+                const datajson = asObject(continuation.datajson, 'continuation.datajson');
+                const response = await sendWrite(env.host, applyName, target.writePath, datajson);
+                return projectSuccess(applyName, response, { targetType: target.entity, writeAction: 'update', id });
+            },
+        },
+    ];
+}
+function deleteOperations(namePrefix, target) {
+    const prepareName = `${namePrefix}.prepare`;
+    const applyName = `${namePrefix}.apply`;
+    return [
+        {
+            name: prepareName,
+            resource: 'project',
+            method: 'write.prepare',
+            action: prepareName,
+            summary: `回查${target.entity === 'task' ? '任务' : '项目'}并生成不可逆删除 continuation，不发生删除`,
+            risk: 'read-before-write',
+            inputSchema: schemaOf({ id: SCHEMA_ID_STRING }, { required: ['id'] }),
+            handler: async (args, env) => {
+                const id = idString(args.id, 'id');
+                const current = await detail(env.host, target, id, prepareName);
+                const datajson = {
+                    header: { operator: await operatorId(env.host) },
+                    datas: [{ mainTable: { id } }],
+                };
+                const continuation = await env.continuation.issue({
+                    operation: applyName,
+                    userId: datajson.header.operator,
+                    id,
+                    fingerprint: stableFingerprint(current),
+                    datajson,
+                });
+                return projectSuccess(prepareName, {
+                    continuation,
+                    request: { datajson },
+                    current,
+                }, { requiresConfirmation: true, id, irreversible: true });
+            },
+        },
+        {
+            name: applyName,
+            resource: 'project',
+            method: 'write.apply',
+            action: applyName,
+            summary: `经用户确认并确认目标未变化后删除${target.entity === 'task' ? '任务' : '项目'}，不可恢复`,
+            risk: 'high-risk-write',
+            requiresConfirmation: true,
+            inputSchema: schemaOf({
+                continuation: SCHEMA_CONTINUATION,
+                confirm: SCHEMA_CONFIRM,
+            }, { required: ['continuation', 'confirm'] }),
+            handler: async (args, env) => {
+                if (args.confirm !== true)
+                    throw projectValidationError('confirm_required', 'confirm 必须为 true');
+                const continuation = await env.continuation.verify(String(args.continuation), applyName);
+                await verifySession(env, continuation);
+                const id = idString(continuation.id, 'continuation.id');
+                const current = await detail(env.host, target, id, applyName);
+                if (stableFingerprint(current) !== continuation.fingerprint) {
+                    throw projectValidationError('target_changed', '目标数据在确认后已变化，请重新执行 prepare');
+                }
+                const datajson = asObject(continuation.datajson, 'continuation.datajson');
+                const response = await sendWrite(env.host, applyName, target.writePath, datajson);
+                return projectSuccess(applyName, response, { targetType: target.entity, writeAction: 'delete', id });
+            },
+        },
+    ];
+}
+export const projectWriteOperations = [
+    ...createOperations('project.task.create', WRITE_TARGETS.taskCreate),
+    ...updateOperations('project.task.update', WRITE_TARGETS.taskUpdate),
+    ...deleteOperations('project.task.delete', WRITE_TARGETS.taskDelete),
+    ...createOperations('project.project.create', WRITE_TARGETS.projectCreate),
+    ...updateOperations('project.project.update', WRITE_TARGETS.projectUpdate),
+    ...deleteOperations('project.project.delete', WRITE_TARGETS.projectDelete),
+];

package/dist/shortcuts/project/operations.js

@@ -0,0 +1,8 @@
+import { getProjectOperation } from './operations/registry.js';
+import { asObject, assertNoForbiddenKeys } from './operations/shared.js';
+export async function executeProjectOperation(operation, rawInput, context) {
+    const definition = getProjectOperation(operation);
+    const input = asObject(rawInput);
+    assertNoForbiddenKeys(input);
+    return definition.handler(input, context);
+}