apaas-oapi-client 0.1.40 → 1.0.0

package/dist/schema-utils.d.ts

@@ -0,0 +1,194 @@
+import type { CreateFieldDefinition, MultilingualText, ObjectSettings, UpdateFieldDefinition } from './field-types';
+export declare const SCHEMA_BATCH_SIZE = 10;
+export type SchemaResponseFailureLayer = 'request' | 'silent' | 'item';
+export interface SchemaResponseItem {
+    api_name?: string;
+    apiName?: string;
+    name?: string;
+    status?: {
+        code?: string | number;
+        message?: string;
+        msg?: string;
+    };
+    [key: string]: any;
+}
+export interface SchemaResponse {
+    code?: string | number;
+    msg?: string;
+    message?: string;
+    data?: {
+        items?: SchemaResponseItem[];
+        [key: string]: any;
+    } | null;
+    [key: string]: any;
+}
+export interface SchemaResponseFailure {
+    layer: SchemaResponseFailureLayer;
+    context: string;
+    code?: string;
+    message: string;
+    apiName?: string;
+    item?: SchemaResponseItem;
+}
+export interface SchemaResponseValidationOptions {
+    requireItemStatus?: boolean;
+    allowDataNull?: boolean;
+}
+export interface SchemaResponseValidationResult<T extends SchemaResponse = SchemaResponse> {
+    ok: boolean;
+    result: T;
+    failures: SchemaResponseFailure[];
+}
+export interface SchemaBatchInfo {
+    batchIndex: number;
+    batchCount: number;
+    start: number;
+    end: number;
+    batchSize: number;
+}
+export interface SchemaBatchExecuteOptions {
+    batchSize?: number;
+    context?: string;
+    continueOnError?: boolean;
+    checkResponse?: boolean;
+    responseOptions?: SchemaResponseValidationOptions;
+}
+export interface SchemaBatchExecuteResult<R extends SchemaResponse = SchemaResponse> {
+    ok: boolean;
+    total: number;
+    batchSize: number;
+    batchCount: number;
+    results: R[];
+    failures: SchemaResponseFailure[];
+}
+export type SchemaStageFieldDefinition = (CreateFieldDefinition | UpdateFieldDefinition) & {
+    operator?: 'add' | 'replace' | 'remove';
+};
+export interface SchemaManagedObjectDefinition {
+    api_name: string;
+    label: MultilingualText;
+    settings?: ObjectSettings;
+    fields?: SchemaStageFieldDefinition[];
+    [key: string]: any;
+}
+export interface SchemaCreateShellsOptions extends SchemaBatchExecuteOptions {
+    skipExisting?: boolean;
+}
+export interface SchemaAddFieldsOptions {
+    context?: string;
+    skipExisting?: boolean;
+    checkResponse?: boolean;
+    responseOptions?: SchemaResponseValidationOptions;
+}
+export interface SchemaAddFieldsResult {
+    objectName: string;
+    addedFields: string[];
+    skippedFields: string[];
+    result?: SchemaResponse;
+}
+export interface SchemaCreateShellsResult {
+    requested: string[];
+    created: string[];
+    skippedExisting: string[];
+    batches?: SchemaBatchExecuteResult;
+}
+export interface SchemaCreateObjectsInStagesOptions extends SchemaBatchExecuteOptions {
+    skipExisting?: boolean;
+    updateFinalSettings?: boolean;
+    verify?: boolean;
+    includeMarkdown?: boolean;
+}
+export interface SchemaCreateObjectsInStagesResult {
+    shells: SchemaCreateShellsResult;
+    baseFields: SchemaAddFieldsResult[];
+    lookupFields: SchemaAddFieldsResult[];
+    referenceFields: SchemaAddFieldsResult[];
+    finalSettings?: SchemaBatchExecuteResult;
+    verification?: SchemaVerificationResult;
+}
+export interface SchemaObjectVerification {
+    objectName: string;
+    exists: boolean;
+    fields: any[];
+    customFields: any[];
+}
+export interface SchemaVerificationResult {
+    objects: SchemaObjectVerification[];
+    markdown?: string;
+}
+export interface SchemaVerificationOptions {
+    includeMarkdown?: boolean;
+}
+export interface SchemaFieldRemovalPlan {
+    referenceFieldObjects: Array<{
+        api_name: string;
+        fields: Array<{
+            operator: 'remove';
+            api_name: string;
+        }>;
+    }>;
+    lookupObjects: Array<{
+        api_name: string;
+        fields: Array<{
+            operator: 'remove';
+            api_name: string;
+        }>;
+    }>;
+    otherFieldObjects: Array<{
+        api_name: string;
+        fields: Array<{
+            operator: 'remove';
+            api_name: string;
+        }>;
+    }>;
+}
+export interface DeleteAllCustomObjectsOptions extends SchemaBatchExecuteOptions {
+    confirm?: boolean;
+    removeOtherFields?: boolean;
+    verify?: boolean;
+}
+export interface DeleteAllCustomObjectsResult {
+    deletedObjects: string[];
+    removalPlan: SchemaFieldRemovalPlan;
+    fieldRemovalResults: SchemaBatchExecuteResult[];
+    deleteResults?: SchemaBatchExecuteResult;
+    remainingObjects?: string[];
+}
+export interface SchemaClientLike {
+    schema: {
+        create(params: any): Promise<SchemaResponse>;
+        update(params: any): Promise<SchemaResponse>;
+        delete(params: any): Promise<SchemaResponse>;
+    };
+    object: {
+        listWithIterator(params?: any): Promise<{
+            items?: any[];
+        }>;
+        metadata: {
+            fields(params: {
+                object_name: string;
+            }): Promise<any>;
+            export2markdown?(options?: {
+                object_names?: string[];
+            }): Promise<string>;
+        };
+    };
+}
+export declare function isSystemSchemaName(apiName: string): boolean;
+export declare function normalizeSchemaObjectsForWrite<T extends {
+    fields?: any[];
+}>(objects: T[]): T[];
+export declare function validateSchemaResponse<T extends SchemaResponse>(result: T, context?: string, options?: SchemaResponseValidationOptions): SchemaResponseValidationResult<T>;
+export declare function checkSchemaResponse<T extends SchemaResponse>(result: T, context?: string, options?: SchemaResponseValidationOptions): T;
+export declare function batchExecute<T, R extends SchemaResponse>(items: T[], fn: (batch: T[], info: SchemaBatchInfo) => Promise<R>, options?: SchemaBatchExecuteOptions): Promise<SchemaBatchExecuteResult<R>>;
+export declare function splitSchemaFieldsByDependency(fields: SchemaStageFieldDefinition[]): {
+    baseFields: SchemaStageFieldDefinition[];
+    lookupFields: SchemaStageFieldDefinition[];
+    referenceFields: SchemaStageFieldDefinition[];
+};
+export declare function createSchemaObjectShells(client: SchemaClientLike, objects: SchemaManagedObjectDefinition[], options?: SchemaCreateShellsOptions): Promise<SchemaCreateShellsResult>;
+export declare function addFieldsIdempotent(client: SchemaClientLike, objectName: string, fieldsToAdd: SchemaStageFieldDefinition[], options?: SchemaAddFieldsOptions): Promise<SchemaAddFieldsResult>;
+export declare function createSchemaObjectsInStages(client: SchemaClientLike, objects: SchemaManagedObjectDefinition[], options?: SchemaCreateObjectsInStagesOptions): Promise<SchemaCreateObjectsInStagesResult>;
+export declare function verifySchemaObjects(client: SchemaClientLike, objectNames: string[], options?: SchemaVerificationOptions): Promise<SchemaVerificationResult>;
+export declare function buildFieldRemovalPlan(fieldsByObject: Record<string, any[]>): SchemaFieldRemovalPlan;
+export declare function deleteAllCustomObjects(client: SchemaClientLike, options?: DeleteAllCustomObjectsOptions): Promise<DeleteAllCustomObjectsResult>;

package/package.json

@@ -1,9 +1,9 @@
 {
     "name": "apaas-oapi-client",
-    "version": "0.1.40",
+    "version": "1.0.0",
     "main": "dist/index.js",
     "bin": {
-        "apaas-oapi-client": "./bin/apaas-oapi-client.js"
+        "apaas-oapi-client": "bin/apaas-oapi-client.js"
     },
     "exports": {
         ".": "./dist/index.js",
@@ -28,7 +28,7 @@
     "author": "",
     "repository": {
         "type": "git",
-        "url": "https://github.com/ennann/apaas-oapi-node-client"
+        "url": "git+https://github.com/ennann/apaas-oapi-node-client.git"
     },
     "license": "ISC",
     "dependencies": {

package/skills/apaas-function-flow/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: apaas-function-flow
-description: "Use for aPaaS Node SDK cloud function and automation flow execution: invoking functions, executing v1/v2 flows, preparing operator payloads, checking returned code/msg/data, and avoiding unsafe repeated workflow submissions."
+description: "Use for aPaaS Node SDK cloud function, automation flow, workflow, user task, and Lark integration token operations: invoking functions, executing v1/v2 flows, querying execution status, task approve/reject/transfer/rollback/chat, checking code/msg/data, and avoiding unsafe repeated workflow submissions."
 ---
 
 # aPaaS Function Flow
 
-Use this skill for `client.function.*` and `client.automation.*`.
+Use this skill for `client.function.*`, `client.automation.*`, `client.workflow.*`, and `client.integration.lark.*`.
 
 ## Function Invoke
 
@@ -42,9 +42,54 @@ const res = await client.automation.v2.execute({
 });
 ```
 
+## Workflow Status And Definition
+
+```ts
+const status = await client.workflow.execution.status({
+  execution_id: "1848390852196499"
+});
+
+const flow = await client.workflow.definition.detail({
+  flow_api_name: "package_xxx__c__action_xxx"
+});
+```
+
+## User Tasks
+
+Use `client.workflow.userTask.*` for human task workflows. Treat approve/reject/transfer/rollback/cancel as writes.
+
+```ts
+const tasks = await client.workflow.userTask.tasks({
+  type: "pending",
+  source: "assignMe",
+  kunlun_user_id: "1783981209205788",
+  limit: 20,
+  offset: 0
+});
+
+await client.workflow.userTask.agree({
+  approval_task_id: "1785996265147395",
+  user_id: "1783981209205788",
+  opinion: "同意"
+});
+```
+
+## Lark Integration Tokens
+
+Use this only when the user needs to call Lark OpenAPI through a configured aPaaS integration.
+
+```ts
+const token = await client.integration.lark.defaultTenantAccessToken();
+
+const customToken = await client.integration.lark.appAccessToken({
+  lark_integration_api_name: "larkIntegration_xxx"
+});
+```
+
 ## Safety
 
 - Treat flow execution as a write operation; confirm before triggering production workflows.
+- Treat user task actions and workflow instance cancel/rollback as write operations.
 - Do not resubmit failed flows with `is_resubmit` unless the user explicitly requests it and `pre_instance_id` is known.
 - Log flow/function names and result codes, not secrets or full sensitive payloads.
 - If the flow mutates records, verify the target record after execution with `apaas-object`.

package/skills/apaas-function-flow/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "aPaaS Function Flow"
-  short_description: "aPaaS 云函数调用和自动化流程执行安全操作指南"
-  default_prompt: "Use $apaas-function-flow to invoke cloud functions or automation flows."
+  short_description: "aPaaS 云函数、自动化流程、工作流人工任务与飞书集成 token 指南"
+  default_prompt: "Use $apaas-function-flow to invoke functions, execute flows, handle workflow user tasks, or fetch Lark integration tokens."

package/skills/apaas-object/SKILL.md

@@ -1,11 +1,11 @@
 ---
 name: apaas-object
-description: "Use for aPaaS Node SDK object metadata and record operations: listing objects, reading fields, exporting metadata to Markdown, querying records, count, create, update, delete, batch operations, pagination, and record-level error recovery."
+description: "Use for aPaaS Node SDK object/data operations: object metadata, fields, Markdown export, record CRUD, batch operations, OQL, cross-object search, constant objects, datasets, pagination, ID cursor pagination, and record-level error recovery."
 ---
 
 # aPaaS Object
 
-Use this skill for `client.object.*`.
+Use this skill for `client.object.*`, `client.constant.*`, and `client.dataset.*`.
 
 ## Workflow
 
@@ -15,6 +15,8 @@ Use this skill for `client.object.*`.
 4. Use iterator helpers for full-result work.
 5. Check SDK response codes and failed item lists.
 
+Read [references/id-cursor-pagination.md](references/id-cursor-pagination.md) when a task needs full-table reads, large offset pagination, or a doc mentions ID cursor pagination.
+
 ## Metadata
 
 Prefer metadata calls before record work:
@@ -42,6 +44,8 @@ Use returned API names, not user-facing labels, in later calls.
 - Use `search.records` for one page.
 - Use `search.recordsWithIterator` for full-table or full-filter tasks.
 - Use `search.count` when only the count is needed.
+- Use `object.oql` when the user gives an OQL statement or needs OQL-only query features.
+- Use `search.recordsAcrossObjects` for global search across up to 5 objects.
 
 ```ts
 const { total, items } = await client.object.search.recordsWithIterator({
@@ -58,6 +62,41 @@ const { total, items } = await client.object.search.recordsWithIterator({
 
 Do not answer global max/min/top/count questions from a single page unless the user asked for a sample.
 
+## OQL And Cross-Object Search
+
+```ts
+const oql = await client.object.oql({
+  query: "SELECT _id, _name FROM _user WHERE _type = $1 LIMIT 10",
+  args: ["_employee"]
+});
+
+const search = await client.object.search.recordsAcrossObjects({
+  q: "Ethan",
+  search_objects: [{
+    api_name: "_user",
+    select: ["_id", "_name"],
+    search_fields: ["_name"]
+  }],
+  page_size: 20,
+  metadata: "Label"
+});
+```
+
+## Constant Objects And Datasets
+
+Use `client.constant.*` for `_currency`, `_country`, and `_timeZone`.
+
+```ts
+const currencies = await client.constant.records({
+  object_name: "_currency",
+  data: { limit: 100, offset: 0, count: false, fields: ["_id", "_name"] }
+});
+
+const datasets = await client.dataset.listWithIterator({
+  page_size: 100
+});
+```
+
 ## Record Writes
 
 Use storage fields only. Re-read metadata when unsure.

package/skills/apaas-object/agents/openai.yaml

@@ -1,4 +1,4 @@
 interface:
   display_name: "aPaaS Object"
-  short_description: "aPaaS 对象元数据、记录读写与分页查询操作指南"
-  default_prompt: "Use $apaas-object to read metadata and operate records with the aPaaS Node SDK."
+  short_description: "aPaaS 对象元数据、记录读写、OQL、跨对象搜索、常量对象与数据集指南"
+  default_prompt: "Use $apaas-object to read metadata and operate aPaaS records, constants, datasets, OQL, or cross-object search."

package/skills/apaas-object/references/id-cursor-pagination.md

@@ -0,0 +1,64 @@
+# ID Cursor Pagination
+
+Use this when an endpoint exposes `limit`/`offset` but does not provide a reliable `page_token`. Large offset queries can become slow and are more likely to hit rate limits.
+
+## Preferred Order
+
+1. Use SDK iterator helpers when available, for example `recordsWithIterator`, `recordsAcrossObjectsWithIterator`, or `dataset.listWithIterator`.
+2. If the endpoint supports `page_token` / `next_page_token`, use token pagination.
+3. If only `limit` / `offset` is available, use ID cursor pagination with `_id`.
+
+## ID Cursor Pattern
+
+Keep `offset: 0`, set `count: false`, filter `_id > lastId`, and sort `_id asc`.
+
+```ts
+let lastId = 0;
+const limit = 200;
+const all: any[] = [];
+
+while (true) {
+  const res = await client.constant.records({
+    object_name: "_currency",
+    data: {
+      offset: 0,
+      limit,
+      count: false,
+      fields: ["_id", "_name"],
+      filter: [{ leftValue: "_id", operator: "gt", rightValue: lastId }],
+      sort: [{ field: "_id", direction: "asc" }]
+    }
+  });
+
+  if (res.code !== "0") throw new Error(res.msg || "query failed");
+
+  const records = res.data?.records || res.data?.items || [];
+  all.push(...records);
+  if (records.length < limit) break;
+
+  lastId = records[records.length - 1]._id;
+}
+```
+
+## Page Token Pattern
+
+For record query endpoints that support token pagination:
+
+```ts
+const { items } = await client.object.search.recordsWithIterator({
+  object_name: "object_store",
+  data: {
+    page_size: 100,
+    use_page_token: true,
+    select: ["_id", "name"],
+    query_deleted_record: false
+  }
+});
+```
+
+## Rules
+
+- Do not parallelize high-offset reads.
+- Do not request `total` or `count` unless the user actually needs it.
+- Always sort by `_id asc` when using `_id` as the cursor.
+- Stop only when the returned page has fewer records than `limit` or when `has_more` is false.

package/skills/apaas-schema/SKILL.md

@@ -17,25 +17,41 @@ Use this skill for `client.schema.*`.
 1. Use `apaas-shared` to initialize the client.
 2. Read current objects with `client.object.listWithIterator()`.
 3. Read existing fields with `client.object.metadata.fields({ object_name })`.
-4. For new objects, create shells first, then add fields with `schema.update`.
-5. For dependency fields, create base fields first, then lookup fields, then reference fields.
-6. Check request-level, silent-failure, and item-level response status.
-7. After the call, re-read metadata to verify the effective schema.
+4. Prefer `client.schema.createWithStages()` for new objects with fields.
+5. Use `client.schema.addFieldsIdempotent()` when adding fields to an existing object.
+6. Check raw schema write responses with `client.schema.checkResponse()`.
+7. After the call, use `client.schema.verifyObjects()` to verify the effective schema.
 
 ## Create Object
 
-Create objects as shells first. Do not rely on `schema.create({ fields })` to create fields.
+Create objects through the SDK staging helper when fields are involved. It creates shells first, then base fields, then lookup fields, then reference fields, then final settings.
 
 ```ts
-await client.schema.create({
+await client.schema.createWithStages({
   objects: [{
     api_name: "product",
     label: { zh_cn: "产品", en_us: "Product" },
     settings: {
-      display_name: "_id",
-      allow_search_fields: ["_id"],
+      display_name: "name",
+      allow_search_fields: ["_id", "name"],
       search_layout: []
-    }
+    },
+    fields: [{
+      operator: "add",
+      api_name: "name",
+      label: { zh_cn: "产品名称", en_us: "Name" },
+      type: {
+        name: "text",
+        settings: {
+          required: true,
+          unique: false,
+          case_sensitive: false,
+          multiline: false,
+          max_length: 100
+        }
+      },
+      encrypt_type: "none"
+    }]
   }]
 });
 ```
@@ -48,19 +64,23 @@ await client.schema.create({
 - Update label/settings without field changes by omitting `fields`.
 
 ```ts
-await client.schema.update({
-  objects: [{
-    api_name: "product",
-    fields: [{
-      operator: "add",
-      api_name: "description",
-      label: { zh_cn: "产品描述", en_us: "Description" },
-      type: {
-        name: "text",
-        settings: { multiline: true, max_length: 100000 }
-      },
-      encrypt_type: "none"
-    }]
+await client.schema.addFieldsIdempotent({
+  object_name: "product",
+  fields: [{
+    operator: "add",
+    api_name: "description",
+    label: { zh_cn: "产品描述", en_us: "Description" },
+    type: {
+      name: "text",
+      settings: {
+        required: false,
+        unique: false,
+        case_sensitive: false,
+        multiline: true,
+        max_length: 100000
+      }
+    },
+    encrypt_type: "none"
   }]
 });
 ```
@@ -70,3 +90,4 @@ await client.schema.update({
 - Confirm the object API names before `client.schema.delete`.
 - Do not delete objects as a cleanup shortcut if records or references may still depend on them.
 - Remove `reference_field` before removing its lookup field.
+- For environment rebuilds, use `client.schema.deleteAllCustomObjects({ confirm: true })`.

package/skills/apaas-schema/references/field-schema-rules.md

@@ -104,9 +104,32 @@ blue, cyan, green, yellow, orange, red, magenta, purple, blueMagenta, grey, blue
 }
 ```
 
+OpenAPI write payloads require color short codes, while metadata returns color names. The SDK normalizes these names before writing, so SDK callers can keep using `blue`, `cyan`, etc.
+
+| Metadata color | OpenAPI write code |
+|---|---|
+| `blue` | `B` |
+| `cyan` | `W` |
+| `green` | `G` |
+| `yellow` | `Y` |
+| `orange` | `O` |
+| `red` | `R` |
+| `magenta` | `V` |
+| `purple` | `P` |
+| `blueMagenta` | `I` |
+| `grey` | `N` |
+
 Do not copy metadata `optionList` back into `schema.update`; convert it to `options`.
 
-Use `getOptionColor(index)` from the SDK to assign colors in this stable 10-color cycle.
+Use `getOptionColor(index)` from the SDK to assign metadata color names in this stable 10-color cycle. Use `getOptionColorCode(color)` only when constructing raw OpenAPI payloads outside the SDK normalizer.
+
+## SQL Conversion Constants
+
+For SQL/ER conversion, use the SDK exports instead of retyping mapping tables:
+
+- `SQL_TYPE_TO_SCHEMA_TYPE`
+- `COLUMN_NAME_SEMANTIC_RULES`
+- `SQL_CONSTRAINT_TO_SETTINGS`
 
 ## Minimal Lookup Example
 

package/skills/apaas-schema/references/schema-maintenance-sop.md

@@ -13,30 +13,17 @@ Use this reference for whole-application object maintenance: reading object stru
 
 ## Response Validation
 
-Check three layers after every schema call:
+Check three layers after every raw schema call with the SDK helper:
 
 ```ts
-function checkSchemaResponse(result: any, context: string) {
-  if (result.code !== "0") {
-    throw new Error(`${context} request failed: ${result.code} ${result.msg || ""}`);
-  }
-
-  if (result.data === null) {
-    throw new Error(`${context} silently failed: result.code is 0 but result.data is null`);
-  }
-
-  const failed = (result.data?.items || []).filter((item: any) => item.status?.code !== "0");
-  if (failed.length > 0) {
-    throw new Error(`${context} item failures: ${JSON.stringify(failed)}`);
-  }
-}
+client.schema.checkResponse(result, "schema.update");
 ```
 
 `code: "0"` with `data: null` is not success. It usually means a required setting is missing, for example `text.multiline` or `auto_number.generation_method`.
 
 ## Create Objects: Three Stages
 
-Do not create a full object with fields in one call. Use this sequence even when there is no obvious dependency cycle.
+Do not create a full object with raw `schema.create({ fields })`. Use `client.schema.createWithStages()` when fields are involved. It enforces this sequence even when there is no obvious dependency cycle.
 
 1. Stage 1a: create object shells only.
 2. Stage 1b: add base fields with `schema.update` and `operator: "add"`.
@@ -45,19 +32,11 @@ Do not create a full object with fields in one call. Use this sequence even when
 5. Final: update `display_name`, `allow_search_fields`, and `search_layout` after fields exist.
 
 ```ts
-await client.schema.create({
+await client.schema.createWithStages({
   objects: [{
     api_name: "customer",
     label: { zh_cn: "客户", en_us: "Customer" },
-    settings: { display_name: "_id", allow_search_fields: ["_id"], search_layout: [] }
-  }]
-});
-```
-
-```ts
-await client.schema.update({
-  objects: [{
-    api_name: "customer",
+    settings: { display_name: "name", allow_search_fields: ["_id", "name"], search_layout: [] },
     fields: [{
       operator: "add",
       api_name: "name",
@@ -86,14 +65,10 @@ await client.schema.update({
 - Skip existing fields when rerunning idempotently.
 
 ```ts
-async function addFieldsIdempotent(client: any, objectName: string, fieldsToAdd: any[]) {
-  const metadata = await client.object.metadata.fields({ object_name: objectName });
-  const existingNames = new Set((metadata.data?.fields || []).map((field: any) => field.apiName));
-  const newFields = fieldsToAdd.filter(field => !existingNames.has(field.api_name));
-  if (newFields.length === 0) return;
-  const result = await client.schema.update({ objects: [{ api_name: objectName, fields: newFields }] });
-  checkSchemaResponse(result, `addFields(${objectName})`);
-}
+await client.schema.addFieldsIdempotent({
+  object_name: "customer",
+  fields: fieldsToAdd
+});
 ```
 
 ## Dependency Order
@@ -116,15 +91,16 @@ Never add a lookup and a reference field that depends on it in the same `schema.
 
 ## Delete All Custom Objects
 
-Use this flow for environment cleanup or model rebuilds:
+Use the SDK helper for environment cleanup or model rebuilds:
+
+```ts
+await client.schema.deleteAllCustomObjects({
+  confirm: true,
+  removeOtherFields: true
+});
+```
 
-1. List objects with `client.object.listWithIterator()`.
-2. Filter out system objects whose API name starts with `_`.
-3. Read fields for each custom object.
-4. Remove `referenceField` fields grouped by object.
-5. Remove `lookup` fields grouped by object.
-6. Delete custom objects in batches of 10.
-7. Re-list objects to verify deletion.
+The helper lists custom objects, reads fields, removes `referenceField`, then `lookup`, then optional other custom fields, deletes objects in batches of 10, and re-lists objects to verify deletion.
 
 ## SQL / ER To aPaaS Mapping