@carthooks/arcubase-cli 0.1.13 → 0.1.15

package/src/tests/execute_validation.test.ts

@@ -146,15 +146,196 @@ test('table update-schema rejects invalid body file', async () => {
 })
 
 test('app create rejects name longer than 20 chars', async () => {
-  const bodyFile = tempJSONFile({ name: 'CLI Verify Happy Path' })
-  await assert.rejects(async () => {
-    await executeCLI('admin', ['app', 'create', '--body-file', bodyFile], env as any, async () => new Response('{}', { status: 200 }))
+	const bodyFile = tempJSONFile({ name: 'CLI Verify Happy Path' })
+	await assert.rejects(async () => {
+		await executeCLI('admin', ['app', 'create', '--body-file', bodyFile], env as any, async () => new Response('{}', { status: 200 }))
   }, (error: unknown) => {
     assert.ok(error instanceof CLIError)
     assert.equal(error.code, 'BODY_VALIDATION_FAILED')
     assert.ok((error.details?.issues ?? []).some((item) => item.path === 'body.name'))
     return true
+	})
+})
+
+test('app create-from-bundle-url posts url body and returns task id', async () => {
+	const calls: Array<{ url: string; method?: string; body?: string }> = []
+	const out = await executeCLI(
+		'admin',
+		['app', 'create-from-bundle-url', '--url', 'https://cdn.example.com/app-bundles/2026/06/17/a.zip', '--name', 'Demo'],
+		env as any,
+		async (url, init) => {
+			calls.push({ url: String(url), method: init?.method, body: String(init?.body ?? '') })
+			return new Response(JSON.stringify({ data: { task_id: 'task-1' } }), { status: 200 })
+		},
+	)
+	assert.equal(calls[0].method, 'POST')
+	assert.match(calls[0].url, /\/api\/apps\/import-task$/)
+	assert.deepEqual(JSON.parse(calls[0].body ?? '{}'), {
+		url: 'https://cdn.example.com/app-bundles/2026/06/17/a.zip',
+		name: 'Demo',
+	})
+	assert.equal((out as any).data.data.task_id, 'task-1')
+	assert.deepEqual((out as any).nextAction, {
+		command: 'app watch-import-task',
+		args: ['--task-id', 'task-1', '--ttl-seconds', '300'],
+		hint: 'run this command until the task returns status=finished and app_id > 0; task_id alone is not success',
+	})
+})
+
+test('app create --url points to bundle import flow', async () => {
+	await assert.rejects(async () => {
+		await executeCLI(
+			'admin',
+			['app', 'create', '--url', 'https://cdn.example.com/app-bundles/2026/06/17/a.zip', '--name', 'Demo'],
+			env as any,
+			async () => new Response('{}', { status: 200 }),
+		)
+	}, (error: unknown) => {
+		assert.ok(error instanceof CLIError)
+		assert.equal(error.code, 'UNKNOWN_FLAG')
+		assert.equal(error.details?.hint, 'app bundle URLs must use app create-from-bundle-url; do not retry app create')
+		assert.deepEqual(error.details?.commonMistakes, [
+			'do not use app create for app bundle URLs',
+			'do not put url inside app create --body-json',
+		])
+		assert.deepEqual(error.details?.suggestions, [
+			'retry with: app create-from-bundle-url --url <public_http_zip_url> --name <app_name>',
+			'then watch with: app watch-import-task --task-id <task_id> --ttl-seconds 300',
+		])
+		return true
+	})
+})
+
+test('app create-from-bundle-url rejects unsupported url scheme before request', async () => {
+	let called = false
+	await assert.rejects(async () => {
+		await executeCLI(
+			'admin',
+			['app', 'create-from-bundle-url', '--url', 'file:///tmp/app.zip', '--name', 'Demo'],
+			env as any,
+			async () => {
+				called = true
+				return new Response('{}', { status: 200 })
+			},
+		)
+	}, (error: unknown) => {
+		assert.ok(error instanceof CLIError)
+		assert.equal(error.code, 'INVALID_IMPORT_URL')
+		assert.equal(called, false)
+		return true
+	})
+})
+
+test('app watch-import-task polls until finished', async () => {
+  const statuses = [
+    { data: { task_id: 'task-1', status: 'processing' } },
+    { data: { task_id: 'task-1', status: 'finished', app_id: 2188889999 } },
+	]
+	const calls: string[] = []
+	const out = await executeCLI(
+		'admin',
+		['app', 'watch-import-task', '--task-id', 'task-1', '--ttl-seconds', '1'],
+		{ ...env, ARCUBASE_IMPORT_TASK_WATCH_INTERVAL_MS: '1' } as any,
+		async (url) => {
+			calls.push(String(url))
+			return new Response(JSON.stringify(statuses.shift()), { status: 200 })
+		},
+	)
+	assert.equal(calls.length, 2)
+  assert.equal((out as any).data.data.status, 'finished')
+})
+
+test('app watch-import-task rejects finished status without app id', async () => {
+	await assert.rejects(async () => {
+		await executeCLI(
+			'admin',
+			['app', 'watch-import-task', '--task-id', 'task-1', '--ttl-seconds', '1'],
+			{ ...env, ARCUBASE_IMPORT_TASK_WATCH_INTERVAL_MS: '1' } as any,
+			async () => new Response(JSON.stringify({ data: { task_id: 'task-1', status: 'finished' } }), { status: 200 }),
+		)
+	}, (error: unknown) => {
+		assert.ok(error instanceof CLIError)
+		assert.equal(error.code, 'IMPORT_TASK_APP_ID_MISSING')
+		return true
+	})
+})
+
+test('row import-csv validates mapping, uploads local file, starts import, and watches task', async () => {
+  const csvFile = tempJSONFile('ID,客户名称\n12,Alice\n').replace(/payload\.json$/, 'records.csv')
+  fs.writeFileSync(csvFile, 'ID,客户名称\n12,Alice\n')
+  const mappingFile = tempJSONFile({
+    mode: 'addorupdate',
+    header: true,
+    dataStartRow: 2,
+    recordId: { header: 'ID' },
+    fields: [{ fieldId: 1001, header: '客户名称' }],
   })
+  const calls: Array<{ url: string; method?: string; body?: string; isForm?: boolean }> = []
+  const out = await executeCLI(
+    'user',
+    ['row', 'import-csv', '--app-id', 'app_1', '--table-id', 'table_1', '--file', csvFile, '--mapping-file', mappingFile, '--ttl-seconds', '1'],
+    { ...env, ARCUBASE_IMPORT_TASK_WATCH_INTERVAL_MS: '1' } as any,
+    async (url, init) => {
+      calls.push({
+        url: String(url),
+        method: init?.method,
+        body: typeof init?.body === 'string' ? init.body : undefined,
+        isForm: init?.body instanceof FormData,
+      })
+      if (String(url).endsWith('/api/entity/app_1/table_1/import') && init?.method === 'POST') {
+        const body = JSON.parse(String(init.body))
+        if (body._import_action === 'init-token') {
+          return new Response(JSON.stringify({ data: { taskId: 'task-1', token: { id: 123, mode: 's3', token_data: { host: 'https://uploads.example.com', dir: 'upload/123/', policy: 'p', signature: 's', accessid: 'a' } } } }), { status: 200 })
+        }
+        if (body._import_action === 'uploaded') {
+          return new Response(JSON.stringify({ data: 'task-1' }), { status: 200 })
+        }
+        if (body._import_action === 'do-process') {
+          assert.deepEqual(body.config, {
+            fileFormat: 'csv',
+            importMode: 'addorupdate',
+            titleRowIndex: 0,
+            csvDelimiter: ',',
+            mapper: { '$id': 0, '1001': 1 },
+          })
+          return new Response(JSON.stringify({ data: { taskId: 'task-1', status: 'processing', state: {} } }), { status: 200 })
+        }
+        if (body._import_action === 'get-state') {
+          return new Response(JSON.stringify({ data: { taskId: 'task-1', status: 'finished', state: { state: { SuccessNum: 1 } } } }), { status: 200 })
+        }
+      }
+      if (String(url) === 'https://uploads.example.com') {
+        return new Response(null, { status: 204 })
+      }
+      throw new Error(`unexpected fetch ${url}`)
+    },
+  )
+  assert.equal(out.kind, 'result')
+  assert.equal(out.data.data.status, 'finished')
+  assert.ok(calls.some((call) => call.isForm), 'expected local file upload form request')
+})
+
+test('row import-csv missing header fails before fetch', async () => {
+  const csvFile = tempJSONFile('Name\nAlice\n').replace(/payload\.json$/, 'records.csv')
+  fs.writeFileSync(csvFile, 'Name\nAlice\n')
+  const mappingFile = tempJSONFile({
+    mode: 'addonly',
+    header: true,
+    dataStartRow: 2,
+    fields: [{ fieldId: 1001, header: 'Missing' }],
+  })
+  let called = false
+  await assert.rejects(async () => {
+    await executeCLI('user', ['row', 'import-csv', '--app-id', 'app_1', '--table-id', 'table_1', '--file', csvFile, '--mapping-file', mappingFile], env as any, async () => {
+      called = true
+      return new Response('{}')
+    })
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'INVALID_IMPORT_MAPPING')
+    return true
+  })
+  assert.equal(called, false)
 })
 
 test('table create rejects empty schema body before request', async () => {
@@ -387,7 +568,7 @@ test('table update-schema rejects per-user permission patches', async () => {
     layout: [[1001], [1002]],
     fields: [
       { id: 1001, label: 'Title', type: 'text', required: true, unique: false, editable: true, visible: true, show_label: true, scannable: false, default_value_mode: 0, description: '', value: null, number_decimal: 0, depends: [], key: 'title', code_index: false, options: { type: 'text', placeholder: '', lengthLimit: false, lengthMin: 0, lengthMax: 255 }, transfers: null, children: null },
-      { id: 1002, label: 'Description', type: 'textarea', required: false, unique: false, editable: true, visible: true, show_label: true, scannable: false, default_value_mode: 0, description: '', value: null, number_decimal: 0, depends: [], key: 'description', code_index: false, options: { placeholder: '', html: false, size: 'default', lengthLimit: false, lengthMin: 0, lengthMax: 2000 }, transfers: null, children: null, permission: { user: { read: false } } },
+      { id: 1002, label: 'Description', type: 'textarea', required: false, unique: false, editable: true, visible: true, show_label: true, scannable: false, default_value_mode: 0, description: '', value: null, number_decimal: 0, depends: [], key: 'description', code_index: false, options: { placeholder: '', html: false, size: 6, lengthLimit: false, lengthMin: 0, lengthMax: 2000 }, transfers: null, children: null, permission: { user: { read: false } } },
     ],
     options: { Buttons: [], CustomActions: [], FrontendEvents: [], TitleFormat: { Fields: [], Parts: [], Body: '' }, misc: {} },
     workflow_enabled: false,
@@ -770,6 +951,45 @@ test('row query rejects camelCase viewMode and points to row crud doc', async ()
   })
 })
 
+test('row query rejects invalid search shape through EntityQueryReqVO zod schema', async () => {
+  for (const search of [
+    { conditions: [{ field_id: 1002, op: 'eq', value: 'member_1' }] },
+    { field_filters: [{ field_id: 1002, operator: 'eq', value: 'member_1' }] },
+    { q: ['SO-1001'] },
+  ]) {
+    const bodyFile = tempJSONFile({ limit: 20, offset: 0, search })
+    let dataQueryFetchCount = 0
+    await assert.rejects(async () => {
+      await executeCLI(
+        'user',
+        ['row', 'query', '--app-id', 'app_1', '--table-id', 'table_1', '--body-file', bodyFile],
+        env as any,
+        withRowPolicyResolver('table_1', ['view'], async () => {
+          dataQueryFetchCount += 1
+          return new Response('{}', { status: 200 })
+        }),
+      )
+    }, (error: unknown) => {
+      assert.ok(error instanceof CLIError)
+      assert.equal(error.code, 'BODY_VALIDATION_FAILED')
+      assert.equal(error.details?.requestType, 'EntityQueryReqVO')
+      assert.ok((error.details?.issues ?? []).some((item) => item.path.startsWith('body.search.')))
+      assert.ok(error.details?.tsHints?.some((item) => item.symbol === 'EntityQueryReqVO' && item.file === '/runtime/arcubase-sdk/types/user-action.ts'))
+      assert.deepEqual(error.details?.shapeHint, {
+        limit: 20,
+        offset: 0,
+        search: { q: 'SO-1001' },
+        sorts: [{ column: ':1001', order: 'asc' }],
+      })
+      assert.ok(error.details?.commonMistakes?.some((item) => item.includes('string route-query keys')))
+      assert.ok(error.details?.suggestions?.some((item) => item.includes('"search":{"q":"SO-1001"}')))
+      assert.ok(error.details?.suggestions?.some((item) => item.includes('"filter_:1002"')))
+      return true
+    })
+    assert.equal(dataQueryFetchCount, 0)
+  }
+})
+
 test('row query unknown limit flag gives body-json retry path', async () => {
   await assert.rejects(async () => {
     await executeCLI('user', ['row', 'query', '--app-id', '2188900691', '--table-id', '2188900694', '--limit', '1', '--offset', '0'], env as any, async () => new Response('{}', { status: 200 }))
@@ -777,7 +997,12 @@ test('row query unknown limit flag gives body-json retry path', async () => {
     assert.ok(error instanceof CLIError)
     assert.equal(error.code, 'UNKNOWN_FLAG')
     assert.equal(error.details?.requestType, 'EntityQueryReqVO')
-    assert.deepEqual(error.details?.shapeHint, { limit: 20, offset: 0, search: { text_search: 'SO-1001' } })
+    assert.deepEqual(error.details?.shapeHint, {
+      limit: 20,
+      offset: 0,
+      search: { q: 'SO-1001' },
+      sorts: [{ column: ':1001', order: 'asc' }],
+    })
     assert.ok(error.details?.suggestions?.some((item) => item.includes('--body-json')))
     return true
   })

package/src/tests/help.test.ts

@@ -66,6 +66,20 @@ test('user row help does not expose internal policy id input', async () => {
   assert.doesNotMatch(out.text, /policy_id/)
 })
 
+test('row import help explains mapping formats and local files', async () => {
+  const excel = await executeCLI('user', ['row', 'import-excel', '--help'], env as any, async () => new Response('{}'))
+  assert.equal(excel.kind, 'help')
+  assert.match(excel.text, /mapping-file/)
+  assert.match(excel.text, /Excel columns use letters/)
+  assert.match(excel.text, /local file/)
+
+  const csv = await executeCLI('user', ['row', 'import-csv', '--help'], env as any, async () => new Response('{}'))
+  assert.equal(csv.kind, 'help')
+  assert.match(csv.text, /CSV mapping uses headers/)
+  assert.match(csv.text, /does not support embedded images/)
+  assert.match(csv.text, /arcubase-admin table get/)
+})
+
 test('admin table update-schema help uses table nouns and body-json', async () => {
   const out = await executeCLI('admin', ['table', 'update-schema', '--help'], env as any, async () => new Response('{}'))
   assert.equal(out.kind, 'help')

package/src/tests/local_upload.test.ts

@@ -0,0 +1,47 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import fs from 'fs'
+import os from 'os'
+import path from 'path'
+import { uploadLocalFileWithToken } from '../runtime/local_upload.js'
+import { CLIError } from '../runtime/errors.js'
+
+function tempFile(name: string, content = 'hello'): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'arcubase-upload-'))
+  const file = path.join(dir, name)
+  fs.writeFileSync(file, content)
+  return file
+}
+
+test('uploadLocalFileWithToken uploads aliyun-compatible post policy', async () => {
+  const file = tempFile('records.csv')
+  const calls: Array<{ url: string; method?: string; body: any }> = []
+  await uploadLocalFileWithToken(file, {
+    mode: 's3',
+    token_data: {
+      host: 'https://uploads.example.com',
+      dir: 'upload/123/',
+      policy: 'policy',
+      signature: 'signature',
+      accessid: 'access',
+      expire: 123,
+    },
+  }, async (url, init) => {
+    calls.push({ url: String(url), method: init?.method, body: init?.body })
+    return new Response(null, { status: 204 })
+  })
+  assert.equal(calls[0].url, 'https://uploads.example.com')
+  assert.equal(calls[0].method, 'POST')
+  assert.ok(calls[0].body instanceof FormData)
+})
+
+test('uploadLocalFileWithToken rejects unsupported token shape', async () => {
+  const file = tempFile('records.csv')
+  await assert.rejects(async () => {
+    await uploadLocalFileWithToken(file, { mode: 'unknown', token_data: {} }, async () => new Response(''))
+  }, (error: unknown) => {
+    assert.ok(error instanceof CLIError)
+    assert.equal(error.code, 'UPLOAD_TOKEN_UNSUPPORTED')
+    return true
+  })
+})

package/src/tests/zod_registry.test.ts

@@ -14,6 +14,33 @@ test('EntityQueryReqVO schema exists', () => {
   assert.ok(getBodySchema('EntityQueryReqVO'))
 })
 
+test('EntityQueryReqVO search only accepts route-query string keys', () => {
+  const schema = getBodySchema('EntityQueryReqVO')
+  assert.ok(schema)
+
+  assert.equal(schema.safeParse({
+    limit: 100,
+    offset: 0,
+    search: {
+      q: 'SO-1001',
+      tab: 'all',
+      'filter_:1002': 'eq:member_1',
+    },
+  }).success, true)
+
+  for (const search of [
+    { conditions: [{ field_id: 1002, op: 'eq', value: 'member_1' }] },
+    { condition: { field_id: 1002, op: 'eq', value: 'member_1' } },
+    { field_filters: [{ field_id: 1002, operator: 'eq', value: 'member_1' }] },
+    { filter: { field_id: 1002, value: 'member_1' } },
+    { order: [{ column: ':1001', order: 'asc' }] },
+    { q: ['SO-1001'] },
+    { 'filter_:1002': { op: 'eq', value: 'member_1' } },
+  ]) {
+    assert.equal(schema.safeParse({ limit: 100, offset: 0, search }).success, false)
+  }
+})
+
 test('unknown request type has no schema and no unsupported reason', () => {
   assert.equal(getBodySchema('DefinitelyMissingReqVO'), null)
   assert.equal(getUnsupportedBodySchemaReason('DefinitelyMissingReqVO'), null)