@carthooks/arcubase-cli 0.1.0

package/dist/tests/execute_validation.test.js

@@ -0,0 +1,41 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { executeCLI } from '../runtime/execute.js';
+import { CLIError } from '../runtime/errors.js';
+const env = {
+    ARCUBASE_BASE_URL: 'https://arcubase.example.com/api/',
+    ARCUBASE_TENANT_ID: 'tenant_1',
+    ARCUBASE_ACCESS_TOKEN: 'tok',
+    ARCUBASE_TRACE_ID: '',
+    ARCUBASE_SUBJECT_TYPE: '',
+    ARCUBASE_SUBJECT_ID: '',
+    ARCUBASE_TOKEN_EXPIRES_AT: '',
+};
+function tempJSONFile(payload) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'arcubase-cli-'));
+    const filePath = path.join(dir, 'payload.json');
+    fs.writeFileSync(filePath, JSON.stringify(payload, null, 2));
+    return filePath;
+}
+test('admin save entity rejects invalid body file', async () => {
+    const invalidFile = tempJSONFile({ name: '订单', layout: 'bad-layout' });
+    await assert.rejects(async () => {
+        await executeCLI('admin', ['entity', 'admin-save-entity', '--app-id', 'app_1', '--entity-id', 'entity_1', '--body-file', invalidFile], env, async () => new Response('{}'));
+    }, (error) => {
+        assert.ok(error instanceof CLIError);
+        assert.equal(error.code, 'BODY_VALIDATION_FAILED');
+        assert.equal(error.details?.requestType, 'EntitySaveReqVO');
+        assert.ok((error.details?.issues ?? []).some((item) => item.path.startsWith('body.layout')));
+        assert.ok((error.details?.tsHints ?? []).some((item) => item.file.startsWith('/opt/arcubase-sdk/')));
+        return true;
+    });
+});
+test('admin create entity executes with valid body file', async () => {
+    const bodyFile = tempJSONFile({ name: '订单', parent: 0 });
+    const out = await executeCLI('admin', ['app', 'create-entity', '--id', 'app_1', '--body-file', bodyFile], env, async (url, init) => new Response(JSON.stringify({ ok: true, url, method: init?.method }), { status: 200 }));
+    assert.equal(out.kind, 'result');
+    assert.equal(out.status, 200);
+});

package/dist/tests/help.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=help.test.d.ts.map

package/dist/tests/help.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.test.d.ts","sourceRoot":"","sources":["../../src/tests/help.test.ts"],"names":[],"mappings":""}

package/dist/tests/help.test.js

@@ -0,0 +1,22 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { executeCLI } from '../runtime/execute.js';
+const env = {
+    ARCUBASE_BASE_URL: 'https://arcubase.example.com/api/',
+    ARCUBASE_TENANT_ID: 'tenant_1',
+    ARCUBASE_ACCESS_TOKEN: 'tok',
+    ARCUBASE_TRACE_ID: '',
+    ARCUBASE_SUBJECT_TYPE: '',
+    ARCUBASE_SUBJECT_ID: '',
+    ARCUBASE_TOKEN_EXPIRES_AT: '',
+};
+test('root help prints modules', async () => {
+    const out = await executeCLI('admin', ['--help'], env, async () => new Response('{}'));
+    assert.equal(out.kind, 'help');
+    assert.match(out.text, /app/);
+});
+test('module help prints create-entity command', async () => {
+    const out = await executeCLI('admin', ['app', '--help'], env, async () => new Response('{}'));
+    assert.equal(out.kind, 'help');
+    assert.match(out.text, /create-entity/);
+});

package/dist/tests/zod_registry.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=zod_registry.test.d.ts.map

package/dist/tests/zod_registry.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zod_registry.test.d.ts","sourceRoot":"","sources":["../../src/tests/zod_registry.test.ts"],"names":[],"mappings":""}

package/dist/tests/zod_registry.test.js

@@ -0,0 +1,26 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { getBodySchema, getUnsupportedBodySchemaReason } from '../runtime/zod_registry.js';
+test('AppCreateEntityReqVO schema exists', () => {
+    assert.ok(getBodySchema('AppCreateEntityReqVO'));
+});
+test('EntitySaveReqVO schema exists', () => {
+    assert.ok(getBodySchema('EntitySaveReqVO'));
+});
+test('EntityQueryReqVO schema exists', () => {
+    assert.ok(getBodySchema('EntityQueryReqVO'));
+});
+test('inline request type schema exists', () => {
+    assert.ok(getBodySchema('{ name: string }'));
+});
+test('intersection request type schema exists', () => {
+    assert.ok(getBodySchema('EntityImportReqVO & EntityImportActionVO'));
+});
+test('manual notification override schema exists', () => {
+    assert.ok(getBodySchema('EntityUpdateNotificationsReqVO'));
+    assert.equal(getUnsupportedBodySchemaReason('EntityUpdateNotificationsReqVO'), null);
+});
+test('unknown request type has no schema and no unsupported reason', () => {
+    assert.equal(getBodySchema('DefinitelyMissingReqVO'), null);
+    assert.equal(getUnsupportedBodySchemaReason('DefinitelyMissingReqVO'), null);
+});

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@carthooks/arcubase-cli",
+  "version": "0.1.0",
+  "description": "Arcubase runtime CLI for admin and user command execution",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": "./dist/index.js"
+  },
+  "bin": {
+    "arcubase-admin": "./dist/bin/arcubase-admin.js",
+    "arcubase": "./dist/bin/arcubase.js"
+  },
+  "files": [
+    "dist",
+    "bundle",
+    "sdk-dist",
+    "src"
+  ],
+  "scripts": {
+    "codegen:commands": "node scripts/generate-command-registry.mjs",
+    "codegen:zod": "node scripts/generate-zod-registry.mjs",
+    "codegen:type-index": "node scripts/generate-type-index.mjs",
+    "bundle": "npm run codegen:commands && npm run codegen:zod && npm run codegen:type-index && tsc && node scripts/bundle-cli.mjs",
+    "build": "npm run bundle && npm run docs:llms",
+    "test": "npm run codegen:commands && npm run codegen:zod && npm run codegen:type-index && tsx --test src/tests/*.test.ts",
+    "watch": "tsc --watch",
+    "type-check": "tsc --noEmit",
+    "docs:llms": "node -e \"\""
+  },
+  "dependencies": {
+    "@carthooks/client-ts": "0.8.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@types/node": "^20.19.0",
+    "esbuild": "^0.25.11",
+    "ts-morph": "^25.0.1",
+    "tsx": "^4.20.6",
+    "typescript": "^5.3.3"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}

package/sdk-dist/api/admin/app-entity-share.ts

@@ -0,0 +1,52 @@
+import { getDefaultClient } from '../../factory'
+
+export interface AppEntityShareItemVO {
+  id: number
+  source_app_id: number
+  source_entity_id: number
+  entity_name: string
+  target_app_id: number
+  target_app_name: string
+  created_at: number
+}
+
+export interface AppGetEntitySharesRespVO {
+  shares: AppEntityShareItemVO[]
+}
+
+export interface AppCreateEntityShareReqVO {
+  source_entity_id: number
+  target_app_ids: number[]
+}
+
+export interface AppDeleteEntityShareReqVO {
+  source_entity_id: number
+  target_app_id: number
+}
+
+// @endpoint GET /api/apps/:app_id/entity-shares
+// @controller AppGetEntityShares
+export async function getAppEntityShares(
+  appId: string
+): Promise<AppGetEntitySharesRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/entity-shares`)
+}
+
+// @endpoint POST /api/apps/:app_id/entity-shares
+// @controller AppCreateEntityShare
+export async function createAppEntityShare(
+  appId: string,
+  data: AppCreateEntityShareReqVO
+): Promise<{ success: boolean }> {
+  return getDefaultClient().post(`/apps/${appId}/entity-shares`, data)
+}
+
+// @endpoint DELETE /api/apps/:app_id/entity-shares
+// @controller AppDeleteEntityShare
+export async function deleteAppEntityShare(
+  appId: string,
+  data: AppDeleteEntityShareReqVO
+): Promise<{ success: boolean }> {
+  return getDefaultClient().delete(`/apps/${appId}/entity-shares`, data)
+}
+

package/sdk-dist/api/admin/app.ts

@@ -0,0 +1,187 @@
+import { getDefaultClient } from '../../factory'
+import type {
+  AppRenameReqVO,
+  AppRenameRespVO,
+  AppCreateByTenantsReqVO,
+  AppCreateByTenantsRespVO,
+  AppCreateEntityReqVO,
+  AppCreateEntityRespVO,
+  AppGetAppSchemaRespVO,
+  AppGetSiteMapsRespVO,
+  AppSaveSiteMapsReqVO,
+  AppUpdateAppReqVO,
+  AppUpdateAppRespVO,
+  AppUpdateI18nReqVO,
+  AppUpdateI18nRespVO,
+  AppGetEntitiesRespVO
+} from '../../types/app'
+import type {
+  AppDeleteWidgetsRespVO,
+  AppGetWidgetsRespVO,
+  AppNewWidgetsReqVO,
+  AppNewWidgetsRespVO,
+  AppUpdateWidgetsReqVO,
+  AppUpdateWidgetsRespVO,
+  AppUpdateWidgetsIngressOptionsReqVO,
+  AppUpdateWidgetsIngressOptionsRespVO,
+  AppPreviewWidgetsDataReqVO,
+  AppPreviewWidgetsDataRespVO,
+  AppWidgetsListRespVO
+} from '../../types/widgets'
+
+// @endpoint PUT /apps/:id/name
+// @controller App.AppRename
+export async function renameApp(
+  id: string,
+  data: AppRenameReqVO
+): Promise<AppRenameRespVO> {
+  return getDefaultClient().put(`/apps/${id}/name`, data)
+}
+
+// @endpoint POST /apps
+// @controller App.CreateAppByTenants
+export async function createAppByTenants(
+  data: AppCreateByTenantsReqVO
+): Promise<AppCreateByTenantsRespVO> {
+  return getDefaultClient().post('/apps', data)
+}
+
+// @endpoint POST /apps/:id/entities
+// @controller App.CreateEntity
+export async function createEntity(
+  id: string,
+  data: AppCreateEntityReqVO
+): Promise<AppCreateEntityRespVO> {
+  return getDefaultClient().post(`/apps/${id}/entities`, data)
+}
+
+// @endpoint DELETE /apps/:id
+// @controller App.DeleteApp
+export async function deleteApp(
+  id: string
+): Promise<boolean> {
+  return getDefaultClient().delete(`/apps/${id}`)
+}
+
+// @endpoint DELETE /apps/:app_id/widgets/:widgets_id
+// @controller App.DeleteWidgets
+export async function deleteWidgets(
+  appId: string,
+  widgetsId: string
+): Promise<boolean> {
+  return getDefaultClient().delete(`/apps/${appId}/widgets/${widgetsId}`)
+}
+
+// @endpoint POST /apps/:id/schema
+// @controller App.GetAppSchema
+export async function getAppSchema(
+  id: string | number,
+  refresh: boolean = false
+): Promise<AppGetAppSchemaRespVO> {
+  // mock cached
+  return getDefaultClient().post(`/apps/${id}/schema`)
+}
+
+// @endpoint GET /apps/:id/entities
+// @controller App.GetEntities
+export async function getEntities(
+  id: string
+): Promise<AppGetEntitiesRespVO> {
+  return getDefaultClient().get(`/apps/${id}/entities`)
+}
+
+// @endpoint GET /permissions/predefined
+// @controller App.GetPredefinedPermissions
+export async function getPredefinedPermissions(): Promise<any[]> {
+  return getDefaultClient().get('/permissions/predefined')
+}
+
+// @endpoint GET /apps/:id/sitemap
+// @controller App.GetSiteMaps
+export async function getSiteMaps(
+  id: string
+): Promise<AppGetSiteMapsRespVO> {
+  return getDefaultClient().get(`/apps/${id}/sitemap`)
+}
+
+// @endpoint GET /apps/:app_id/widgets/:widgets_id
+// @controller App.GetWidgets
+export async function getWidgets(
+  appId: string,
+  widgetsId: string
+): Promise<AppGetWidgetsRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/widgets/${widgetsId}`)
+}
+
+// @endpoint POST /apps/:app_id/widgets
+// @controller App.NewWidgets
+export async function newWidgets(
+  appId: string,
+  data: AppNewWidgetsReqVO
+): Promise<AppNewWidgetsRespVO> {
+  return getDefaultClient().post(`/apps/${appId}/widgets`, data)
+}
+
+// @endpoint POST /apps/:app_id/widgets-preview
+// @controller App.PreviewWidgetsData
+export async function previewWidgetsData(
+  appId: string,
+  data: AppPreviewWidgetsDataReqVO
+): Promise<AppPreviewWidgetsDataRespVO> {
+  return getDefaultClient().post(`/apps/${appId}/widgets-preview`, data)
+}
+
+// @endpoint PUT /apps/:id/sitemap
+// @controller App.SaveSiteMaps
+export async function saveSiteMaps(
+  id: string,
+  data: AppSaveSiteMapsReqVO
+): Promise<AppGetSiteMapsRespVO> {
+  return getDefaultClient().put(`/apps/${id}/sitemap`, data)
+}
+
+// @endpoint PUT /apps/:id
+// @controller App.UpdateApp
+export async function updateApp(
+  id: string,
+  data: AppUpdateAppReqVO
+): Promise<AppUpdateAppRespVO> {
+  return getDefaultClient().put(`/apps/${id}`, data)
+}
+
+// @endpoint PUT /apps/:app_id/i18n
+// @controller App.UpdateI18n
+export async function updateI18n(
+  appId: string,
+  data: AppUpdateI18nReqVO
+): Promise<AppUpdateI18nRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/i18n`, data)
+}
+
+// @endpoint PUT /apps/:app_id/widgets/:widgets_id
+// @controller App.UpdateWidgets
+export async function updateWidgets(
+  appId: string,
+  widgetsId: string,
+  data: AppUpdateWidgetsReqVO
+): Promise<AppUpdateWidgetsRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/widgets/${widgetsId}`, data)
+}
+
+// @endpoint PUT /apps/:app_id/widgets/:widgets_id/ingress-options
+// @controller App.UpdateWidgetsIngressOptions
+export async function updateWidgetsIngressOptions(
+  appId: string,
+  widgetsId: string,
+  data: AppUpdateWidgetsIngressOptionsReqVO
+): Promise<AppUpdateWidgetsIngressOptionsRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/widgets/${widgetsId}/ingress-options`, data)
+}
+
+// @endpoint GET /apps/:app_id/widgets
+// @controller App.WidgetsList
+export async function widgetsList(
+  appId: string
+): Promise<AppWidgetsListRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/widgets`)
+}

package/sdk-dist/api/admin/automate-rule.ts

@@ -0,0 +1,59 @@
+import { getDefaultClient } from '../../factory'
+import type {
+  AutomateRuleCreateReqVO,
+  AutomateRuleCreateRespVO,
+  AutomateRuleUpdateReqVO,
+  AutomateRuleUpdateRespVO,
+  AutomateRuleGetRespVO,
+  AutomateRuleListRespVO
+} from '../../types/automate-rule'
+
+// @endpoint POST /apps/:app_id/entity/:entity_id/automate-rules
+// @controller AutomateRule.Create
+export async function createAutomateRule(
+  appId: string,
+  entityId: string,
+  data: AutomateRuleCreateReqVO
+): Promise<AutomateRuleCreateRespVO> {
+  return getDefaultClient().post(`/apps/${appId}/entity/${entityId}/automate-rules`, data)
+}
+
+// @endpoint PUT /apps/:app_id/entity/:entity_id/automate-rules/:rule_id
+// @controller AutomateRule.Update
+export async function updateAutomateRule(
+  appId: string,
+  entityId: string,
+  ruleId: string,
+  data: AutomateRuleUpdateReqVO
+): Promise<AutomateRuleUpdateRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/entity/${entityId}/automate-rules/${ruleId}`, data)
+}
+
+// @endpoint DELETE /apps/:app_id/entity/:entity_id/automate-rules/:rule_id
+// @controller AutomateRule.Delete
+export async function deleteAutomateRule(
+  appId: string,
+  entityId: string,
+  ruleId: string
+): Promise<{ success: boolean }> {
+  return getDefaultClient().delete(`/apps/${appId}/entity/${entityId}/automate-rules/${ruleId}`)
+}
+
+// @endpoint GET /apps/:app_id/entity/:entity_id/automate-rules
+// @controller AutomateRule.List
+export async function listAutomateRules(
+  appId: string,
+  entityId: string
+): Promise<AutomateRuleListRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/entity/${entityId}/automate-rules`)
+}
+
+// @endpoint GET /apps/:app_id/entity/:entity_id/automate-rules/:rule_id
+// @controller AutomateRule.Get
+export async function getAutomateRule(
+  appId: string,
+  entityId: string,
+  ruleId: string
+): Promise<AutomateRuleGetRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/entity/${entityId}/automate-rules/${ruleId}`)
+}

package/sdk-dist/api/admin/business-hooks.ts

@@ -0,0 +1,17 @@
+import { getDefaultClient } from '../../factory'
+import type {
+  BusinessHooksGetAvailableHookletsRespVO,
+  BusinessHooksGetAppConnectionsRespVO
+} from '../../types/business-hooks'
+
+// @endpoint GET /api/business-hooks/available-hooklets
+// @controller BusinessHooks.GetAvailableHooklets
+export async function getAvailableHooklets(): Promise<BusinessHooksGetAvailableHookletsRespVO> {
+  return getDefaultClient().get('/business-hooks/available-hooklets')
+}
+
+// @endpoint GET /api/apps/:app_id/business-hooks/connections
+// @controller BusinessHooks.GetAppConnections
+export async function getAppConnections(appId: string): Promise<BusinessHooksGetAppConnectionsRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/business-hooks/connections`)
+}

package/sdk-dist/api/admin/config.ts

@@ -0,0 +1,12 @@
+import { getDefaultClient } from '../../factory'
+
+export interface AWSConfigVO {
+  account_id: string;
+  region: string;
+}
+
+// @endpoint GET /config/aws
+// @controller App.GetAWSConfig
+export async function getAWSConfig(): Promise<AWSConfigVO> {
+  return getDefaultClient().get('/config/aws')
+}

package/sdk-dist/api/admin/dashboard.ts

@@ -0,0 +1,88 @@
+import { getDefaultClient } from '../../factory'
+import type {
+  DashboardCreateReqVO,
+  DashboardCreateRespVO,
+  DashboardFetchOptionsRespVO,
+  DashboardGetListRespVO,
+  DashboardUpdateLayoutReqVO,
+  DashboardUpdateLayoutRespVO,
+  DashboardUpdateOptionsReqVO,
+  DashboardUpdateOptionsRespVO,
+  DashboardUpdateTitleReqVO,
+  DashboardUpdateTitleRespVO
+} from '../../types/dashboard'
+
+// @endpoint POST /apps/:app_id/dashboard
+// @controller Dashboard.Create
+export async function createDashboard(
+  appId: string,
+  data: DashboardCreateReqVO
+): Promise<DashboardCreateRespVO> {
+  return getDefaultClient().post(`/apps/${appId}/dashboard`, data)
+}
+
+// @endpoint GET /apps/:app_id/dashboard/:dashboard_id/options
+// @controller Dashboard.FetchOptions
+export async function getDashboardOptions(
+  appId: string,
+  dashboardId: string
+): Promise<DashboardFetchOptionsRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/dashboard/${dashboardId}/options`)
+}
+
+// @endpoint GET /apps/:app_id/dashboard
+// @controller Dashboard.GetList
+export async function getDashboardList(
+  appId: string
+): Promise<DashboardGetListRespVO> {
+  return getDefaultClient().get(`/apps/${appId}/dashboard`)
+}
+
+// @endpoint PUT /apps/:app_id/dashboard/:dashboard_id/layout
+// @controller Dashboard.UpdateLayout
+export async function updateDashboardLayout(
+  appId: string,
+  dashboardId: string,
+  data: DashboardUpdateLayoutReqVO
+): Promise<DashboardUpdateLayoutRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/dashboard/${dashboardId}/layout`, data)
+}
+
+// @endpoint PUT /apps/:app_id/dashboard/:dashboard_id/options
+// @controller Dashboard.UpdateOptions
+export async function updateDashboardOptions(
+  appId: string,
+  dashboardId: string,
+  data: DashboardUpdateOptionsReqVO
+): Promise<DashboardUpdateOptionsRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/dashboard/${dashboardId}/options`, data)
+}
+
+// @endpoint PUT /apps/:app_id/dashboard/:dashboard_id/label
+// @controller Dashboard.UpdateTitle
+export async function updateDashboardTitle(
+  appId: string,
+  dashboardId: string,
+  data: DashboardUpdateTitleReqVO
+): Promise<DashboardUpdateTitleRespVO> {
+  return getDefaultClient().put(`/apps/${appId}/dashboard/${dashboardId}/label`, data)
+}
+
+// @endpoint DELETE /apps/:app_id/dashboard/:dashboard_id
+// @controller Dashboard.Delete
+export async function deleteDashboard(
+  appId: string,
+  dashboardId: string
+): Promise<any> {
+  return getDefaultClient().delete(`/apps/${appId}/dashboard/${dashboardId}`)
+}
+
+// @endpoint POST /apps/:app_id/dashboard/:dashboard_id/clone
+// @controller Dashboard.Clone
+export async function cloneDashboard(
+  appId: string,
+  dashboardId: string,
+  data: { name: string }
+): Promise<any> {
+  return getDefaultClient().post(`/apps/${appId}/dashboard/${dashboardId}/clone`, data)
+}