@guanwenai/high-tech-project-cli 0.1.0

package/scripts/services/shared.mjs

@@ -0,0 +1,234 @@
+import { readFile } from 'node:fs/promises';
+import { basename, extname, isAbsolute } from 'node:path';
+
+import { CliError } from '../core/errors.mjs';
+import { resolveWithinBase } from '../core/files.mjs';
+
+export const PROJECT_CONTEXT = ['gatewayUrl', 'uuid'];
+export const PROJECT_WRITING_INTERNAL_PREFIX = '/api/internal/v1/project-writing/';
+
+export function toInternalProjectWritingPath(path) {
+  if (typeof path !== 'string' || !path.startsWith('/api/project-writing/')) {
+    return path;
+  }
+  return `${PROJECT_WRITING_INTERNAL_PREFIX}${path.slice('/api/project-writing/'.length)}`;
+}
+
+export function objectInput(input) {
+  if (input === null || Array.isArray(input) || typeof input !== 'object') {
+    throw new CliError('ARGUMENT_INVALID', '命令输入必须是对象');
+  }
+  return input;
+}
+
+export function valueOf(input, snakeName, camelName = snakeName) {
+  return input[snakeName] ?? input[camelName];
+}
+
+export function positiveId(value, field) {
+  if (!Number.isSafeInteger(value) || value <= 0) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 必须是正整数`);
+  }
+  return value;
+}
+
+export function optionalPositiveId(input, snakeName, camelName = snakeName) {
+  const value = valueOf(input, snakeName, camelName);
+  if (value !== undefined) positiveId(value, snakeName);
+  return value;
+}
+
+export function pageInput(input) {
+  const value = objectInput(input);
+  const pageNumber = valueOf(value, 'page_number', 'pageNumber');
+  const pageSize = valueOf(value, 'page_size', 'pageSize');
+  if (pageNumber !== undefined) positiveId(pageNumber, 'page_number');
+  if (pageSize !== undefined) positiveId(pageSize, 'page_size');
+  return value;
+}
+
+export function itemsInput(input) {
+  const value = objectInput(input);
+  if (!Array.isArray(value.items) || value.items.length === 0
+    || value.items.some((item) => item === null || Array.isArray(item) || typeof item !== 'object')) {
+    throw new CliError('ARGUMENT_INVALID', 'items 必须是非空对象数组');
+  }
+  return value;
+}
+
+export function idsInput(input) {
+  const value = objectInput(input);
+  const ids = value.ids;
+  if (!Array.isArray(ids) || ids.length === 0
+    || ids.some((id) => !Number.isSafeInteger(id) || id <= 0)) {
+    throw new CliError('ARGUMENT_INVALID', 'ids 必须是非空正整数数组');
+  }
+  return value;
+}
+
+export function contentInput(input) {
+  const value = objectInput(input);
+  const content = valueOf(value, 'content');
+  if (typeof content !== 'string' || !content.trim()) {
+    throw new CliError('ARGUMENT_INVALID', 'content 不能为空');
+  }
+  return value;
+}
+
+export function relativePathInput(value, field) {
+  if (typeof value !== 'string' || !value.trim() || isAbsolute(value)
+    || value.split(/[\\/]/u).includes('..')) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 必须是工作目录内的相对路径`);
+  }
+  return value;
+}
+
+export function requiredString(value, field) {
+  if (typeof value !== 'string' || !value.trim()) {
+    throw new CliError('ARGUMENT_INVALID', `${field} 不能为空`);
+  }
+  return value.trim();
+}
+
+function remotePath(value) {
+  return /^https?:\/\//iu.test(value) || value.startsWith('/');
+}
+
+function uploadedPath(uploaded) {
+  const path = typeof uploaded === 'string'
+    ? uploaded
+    : uploaded?.filePath ?? uploaded?.url ?? uploaded?.path;
+  if (typeof path !== 'string' || !path.trim()) {
+    throw new CliError('BUSINESS_ERROR', '文件上传未返回 filePath');
+  }
+  return path;
+}
+
+export async function resolveFileReference({
+  client, context, baseDir, filePath, fileName, fileSize,
+}) {
+  const requestedPath = requiredString(filePath, 'file_path');
+  const requestedName = requiredString(fileName || basename(requestedPath), 'file_name');
+  if (remotePath(requestedPath)) {
+    return { fileName: requestedName, filePath: requestedPath, fileSize };
+  }
+  if (typeof baseDir !== 'string' || !baseDir) {
+    throw new CliError('CONFIG_MISSING', '文件操作缺少 baseDir');
+  }
+  const resolvedPath = resolveWithinBase(requestedPath, baseDir);
+  let content;
+  try {
+    content = await readFile(resolvedPath);
+  } catch {
+    throw new CliError('FILE_NOT_FOUND', '文件不存在', {
+      relativePath: requestedPath,
+      baseDir,
+      resolvedPath,
+    });
+  }
+  const actualName = requestedName.includes('.')
+    ? requestedName
+    : `${requestedName}${extname(resolvedPath)}`;
+  const formData = new FormData();
+  formData.append('uuid', context.uuid);
+  formData.append('fileName', actualName);
+  formData.append('file', new Blob([content]), basename(actualName));
+  const uploaded = await client.upload({
+    path: `${PROJECT_WRITING_INTERNAL_PREFIX}file/workspace-upload`,
+    formData,
+  });
+  return { fileName: actualName, filePath: uploadedPath(uploaded), fileSize: content.length };
+}
+
+export async function resolveSmartImportFiles({ client, context, baseDir, fileNames }) {
+  const names = [...new Set(fileNames.map((name) => String(name).trim()).filter(Boolean))];
+  const files = [];
+  const unresolved = [];
+  for (const name of names) {
+    if (typeof baseDir !== 'string' || !baseDir || /^https?:\/\//iu.test(name) || name.startsWith('/')) {
+      unresolved.push(name);
+      continue;
+    }
+    try {
+      const reference = await resolveFileReference({
+        client,
+        context,
+        baseDir,
+        filePath: name,
+        fileName: basename(name),
+      });
+      files.push(reference);
+    } catch (error) {
+      if (error?.code === 'FILE_NOT_FOUND' || error?.code === 'FILE_OUTSIDE_BASE') {
+        unresolved.push(name);
+      } else {
+        throw error;
+      }
+    }
+  }
+  return { files, unresolved };
+}
+
+export function createFileCommand({ name, path, idField, extraFields = [], validate }) {
+  return {
+    name,
+    method: 'POST',
+    path,
+    idempotent: false,
+    multipart: false,
+    requiredContext: PROJECT_CONTEXT,
+    validate,
+    handler: async ({ client, context, input, baseDir }) => {
+      const reference = await resolveFileReference({
+        client,
+        context,
+        baseDir,
+        filePath: valueOf(input, 'file_path', 'filePath'),
+        fileName: valueOf(input, 'file_name', 'fileName'),
+        fileSize: input.fileSize,
+      });
+      const body = {
+        ...extraFields.reduce((result, field) => {
+          const value = valueOf(input, field.snake, field.camel);
+          if (value !== undefined) result[field.camel] = value;
+          return result;
+        }, {}),
+        ...reference,
+        uuid: context.uuid,
+      };
+      if (idField) body[idField] = valueOf(input, idField.replace(/[A-Z]/g, (match) => `_${match.toLowerCase()}`), idField);
+      return await client.request({ method: 'POST', path, body, idempotent: false });
+    },
+  };
+}
+
+export function withJavaMethod(command, javaMethod) {
+  if (!javaMethod) return command;
+  const internalPath = toInternalProjectWritingPath(command.path);
+  return {
+    ...command,
+    path: internalPath,
+    javaMethod,
+    handler: async ({ client, ...input }) => command.handler({
+      ...input,
+      client: client && {
+        request: (request) => client.request({
+          ...request,
+          path: toInternalProjectWritingPath(request.path),
+        }),
+        upload: client.upload
+          ? (request) => client.upload({
+            ...request,
+            path: toInternalProjectWritingPath(request.path),
+          })
+          : undefined,
+        download: client.download
+          ? (request) => client.download({
+            ...request,
+            path: toInternalProjectWritingPath(request.path),
+          })
+          : undefined,
+      },
+    }),
+  };
+}