@carthooks/arcubase-cli 0.1.2 → 0.1.3

package/src/runtime/entity_save_schema.ts

@@ -0,0 +1,708 @@
+import { z } from 'zod'
+import { EntityOptionsSchema, EntitySerialUpdaterVOSchema } from '../generated/zod_registry.generated.js'
+
+const simpleFieldTypes = [
+  'text',
+  'textarea',
+  'number',
+  'datetime',
+  'boolean',
+  'button',
+  'address',
+  'datasets',
+  'department',
+  'departments',
+  'divider',
+  'file',
+  'image',
+  'location',
+  'member',
+  'members',
+  'signature',
+  'tags',
+  'workflow_status',
+  'mobile',
+] as const
+
+const enumFieldTypes = ['select', 'selects', 'radio', 'checkbox', 'status'] as const
+const relationFieldTypes = ['linkto', 'relation', 'query'] as const
+const strictFieldTypes = new Set<string>([
+  ...simpleFieldTypes,
+  ...enumFieldTypes,
+  ...relationFieldTypes,
+  'formula',
+  'lookup',
+  'relationfield',
+  'rollup',
+  'serialnumber',
+  'subform',
+])
+
+const relationTypeSchema = z.union([z.literal('entity'), z.literal('aggregation')])
+const linkModeSchema = z.union([z.literal('manual'), z.literal('auto')])
+const linkStructureSchema = z.union([z.literal('single'), z.literal('multiple')])
+
+const enumItemSchema = z.object({
+  key: z.union([z.number(), z.string()]).optional(),
+  value: z.string().min(1),
+}).passthrough()
+
+const statusItemSchema = z.object({
+  key: z.union([z.number(), z.string()]).optional(),
+  code: z.union([z.number(), z.string()]),
+  value: z.string().min(1),
+}).passthrough()
+
+const sortConfigSchema = z.object({
+  column: z.string().min(1),
+  order: z.union([z.literal('asc'), z.literal('desc')]),
+}).strict()
+
+const relationOptionsSchema = z.object({
+  entity_id: z.number().int().positive(),
+  app_id: z.number().int().positive(),
+  type: relationTypeSchema,
+  show_fields: z.array(z.number().int().positive()).optional(),
+  condition: z.record(z.string(), z.any()).optional(),
+  sorts: z.array(sortConfigSchema).optional(),
+  queryFields: z.array(z.number().int().positive()).optional(),
+  subform_id: z.number().int().positive().optional(),
+}).strict()
+
+const lookupRelationSchema = z.object({
+  local_linkto_field_id: z.number().int().min(1001),
+  target_field_id: z.number().int().min(1001),
+  target_field_type: z.string().min(1),
+}).strict()
+
+const relationFieldRelationSchema = z.object({
+  app_id: z.number().int().positive(),
+  entity_id: z.number().int().positive(),
+  type: relationTypeSchema.optional(),
+  show_fields: z.array(z.number().int().positive()).optional(),
+  condition: z.record(z.string(), z.any()).optional(),
+  sorts: z.array(sortConfigSchema).optional(),
+  queryFields: z.array(z.number().int().positive()).optional(),
+  subform_id: z.number().int().positive().optional(),
+}).strict()
+
+const formulaSchema = z.object({
+  code: z.string().min(1),
+  jsonlogic: z.record(z.string(), z.any()),
+}).strict()
+
+const serialPartBuildinStringSchema = z.object({
+  mode: z.literal('buildin'),
+  type: z.literal('string'),
+  options: z.object({
+    value: z.string(),
+  }).strict(),
+}).strict()
+
+const serialPartBuildinDateSchema = z.object({
+  mode: z.literal('buildin'),
+  type: z.literal('date'),
+  options: z.object({
+    format: z.string().optional(),
+    perdefined: z.boolean().optional(),
+    perdefinedFormat: z.string().optional(),
+  }).strict().refine((value) => Boolean(value.format || value.perdefinedFormat), {
+    message: 'date serial part requires format or perdefinedFormat',
+  }),
+}).strict()
+
+const serialPartBuildinSerialSchema = z.object({
+  mode: z.literal('buildin'),
+  type: z.literal('serial'),
+  options: z.object({
+    length: z.number().int().min(1),
+    lenfixed: z.boolean().optional(),
+    random: z.boolean().optional(),
+    reset: z.string().optional(),
+  }).strict(),
+}).strict()
+
+const serialPartFieldSchema = z.object({
+  mode: z.literal('field'),
+  field_id: z.number().int().min(1001),
+}).passthrough()
+
+const serialPartSchema = z.union([
+  serialPartBuildinStringSchema,
+  serialPartBuildinDateSchema,
+  serialPartBuildinSerialSchema,
+  serialPartFieldSchema,
+])
+
+const fieldCommonShape = {
+  id: z.number().int().min(1001),
+  label: z.string().min(1),
+  required: z.boolean(),
+  unique: z.boolean(),
+  editable: z.boolean(),
+  visible: z.boolean(),
+  show_label: z.boolean(),
+  scannable: z.boolean(),
+  default_value_mode: z.number(),
+  description: z.string(),
+  value: z.any(),
+  number_decimal: z.number().int().min(0),
+  depends: z.array(z.number().int().min(1001)),
+  key: z.string(),
+  code_index: z.boolean(),
+  transfers: z.array(z.any()).nullable(),
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return Boolean(value) && typeof value === 'object' && !Array.isArray(value)
+}
+
+function cloneJSON<T>(value: T): T {
+  return JSON.parse(JSON.stringify(value)) as T
+}
+
+function makeSimpleFieldSchema(type: string) {
+  return z.object({
+    ...fieldCommonShape,
+    type: z.literal(type),
+    options: z.record(z.string(), z.any()).nullable(),
+    children: z.null(),
+  }).strict()
+}
+
+function makeEnumFieldSchema(type: typeof enumFieldTypes[number]) {
+  const itemSchema = type === 'status' ? statusItemSchema : enumItemSchema
+  return z.object({
+    ...fieldCommonShape,
+    type: z.literal(type),
+    options: z.object({
+      options: z.object({
+        items: z.array(itemSchema).min(1),
+      }).passthrough(),
+    }).passthrough(),
+    children: z.null(),
+  }).strict()
+}
+
+const simpleFieldSchemas = simpleFieldTypes.map((type) => makeSimpleFieldSchema(type))
+const enumFieldSchemas = enumFieldTypes.map((type) => makeEnumFieldSchema(type))
+
+const formulaFieldSchema = z.object({
+  ...fieldCommonShape,
+  type: z.literal('formula'),
+  options: z.object({
+    formula: formulaSchema,
+  }).passthrough(),
+  children: z.null(),
+}).strict()
+
+const relationFieldSchemas = relationFieldTypes.map((type) =>
+  z.object({
+    ...fieldCommonShape,
+    type: z.literal(type),
+    options: z.object({
+      relation: relationOptionsSchema,
+      mode: linkModeSchema.optional(),
+      structure: linkStructureSchema.optional(),
+      multiple: z.boolean().optional(),
+      backfill: z.array(z.object({
+        id: z.number().int().min(1001),
+        local_id: z.number().int().min(1001),
+      }).strict()).optional(),
+      addValue: z.boolean().optional(),
+      placeholder: z.string().optional(),
+    }).passthrough(),
+    children: z.null(),
+  }).strict(),
+)
+
+const lookupFieldSchema = z.object({
+  ...fieldCommonShape,
+  type: z.literal('lookup'),
+  options: z.object({
+    relation: lookupRelationSchema,
+  }).passthrough(),
+  children: z.null(),
+}).strict()
+
+const relationFieldFieldSchema = z.object({
+  ...fieldCommonShape,
+  type: z.literal('relationfield'),
+  options: z.object({
+    relation: relationFieldRelationSchema,
+  }).passthrough(),
+  children: z.null(),
+}).strict()
+
+const rollupFieldSchema = z.object({
+  ...fieldCommonShape,
+  type: z.literal('rollup'),
+  options: z.object({
+    relation: lookupRelationSchema,
+    aggregation_formula: formulaSchema,
+  }).passthrough(),
+  children: z.null(),
+}).strict()
+
+const serialNumberFieldSchema = z.object({
+  ...fieldCommonShape,
+  type: z.literal('serialnumber'),
+  options: z.object({
+    parts: z.array(serialPartSchema).min(1),
+  }).passthrough(),
+  children: z.null(),
+}).strict()
+
+const genericFieldSchema = z.object({
+  ...fieldCommonShape,
+  type: z.string().min(1).refine((value) => !strictFieldTypes.has(value), {
+    message: 'known field type must use dedicated schema',
+  }),
+  options: z.record(z.string(), z.any()).nullable(),
+  children: z.null(),
+}).strict()
+
+const baseFieldSchemaVariants = [
+  ...simpleFieldSchemas,
+  ...enumFieldSchemas,
+  ...relationFieldSchemas,
+  formulaFieldSchema,
+  lookupFieldSchema,
+  relationFieldFieldSchema,
+  rollupFieldSchema,
+  serialNumberFieldSchema,
+  genericFieldSchema,
+] as unknown as [z.ZodTypeAny, z.ZodTypeAny, ...z.ZodTypeAny[]]
+
+export const BaseFieldSchema: z.ZodTypeAny = z.union(baseFieldSchemaVariants)
+
+export const SubformFieldSchema: z.ZodTypeAny = z.lazy(() =>
+  z.object({
+    ...fieldCommonShape,
+    type: z.literal('subform'),
+    options: z.record(z.string(), z.any()).nullable(),
+    children: z.array(BaseFieldSchema),
+    layout: z.array(z.array(z.number().int().min(1001))).optional(),
+  }).strict(),
+)
+
+export const FieldVOSchema: z.ZodTypeAny = z.lazy(() =>
+  z.union([
+    SubformFieldSchema,
+    BaseFieldSchema,
+  ]),
+)
+
+function normalizeEntitySaveInput(value: unknown): unknown {
+  if (!isRecord(value)) {
+    return value
+  }
+  const entity = cloneJSON(value)
+  if (entity.layout === null) {
+    entity.layout = []
+  }
+  if (entity.current_serial === null) {
+    delete entity.current_serial
+  }
+  if (isRecord(entity.options)) {
+    if (entity.options.Buttons === null) {
+      entity.options.Buttons = []
+    }
+    if (entity.options.CustomActions === null) {
+      entity.options.CustomActions = []
+    }
+    if (entity.options.FrontendEvents === null) {
+      entity.options.FrontendEvents = []
+    }
+    if (entity.options.misc === null) {
+      entity.options.misc = {}
+    }
+    if (isRecord(entity.options.TitleFormat)) {
+      if (entity.options.TitleFormat.Fields === null) {
+        entity.options.TitleFormat.Fields = []
+      }
+      if (entity.options.TitleFormat.Parts === null) {
+        entity.options.TitleFormat.Parts = []
+      }
+    }
+  }
+  return entity
+}
+
+function collectAllFieldIds(fields: ReadonlyArray<any>): number[] {
+  const out: number[] = []
+  for (const field of fields) {
+    out.push(field.id)
+    if (field.type === 'subform' && Array.isArray(field.children)) {
+      for (const child of field.children) {
+        out.push(child.id)
+      }
+    }
+  }
+  return out
+}
+
+function collectTopLevelFieldIds(fields: ReadonlyArray<any>): number[] {
+  return fields.map((field) => field.id)
+}
+
+function extractFormulaFieldIds(value: unknown): number[] {
+  if (!value || typeof value !== 'string') return []
+  const ids = [...value.matchAll(/:(\d+)\]\]/g)].map((match) => Number(match[1]))
+  return ids.filter((id) => Number.isInteger(id) && id > 0)
+}
+
+const EntitySaveReqVOBaseSchema = z.object({
+    app_id: z.number().optional(),
+    current_serial: EntitySerialUpdaterVOSchema.optional(),
+    field_id_seq: z.number().int(),
+    fields: z.array(FieldVOSchema),
+    id: z.number().optional(),
+    layout: z.array(z.array(z.number().int().min(1001))).optional(),
+    name: z.string().optional(),
+    options: EntityOptionsSchema.optional(),
+    prototypes: z.array(z.number()).optional(),
+    schema_version: z.number().optional(),
+    workflow_enabled: z.boolean().optional(),
+  }).strict().superRefine((entity, ctx) => {
+    const fields = entity.fields
+    const topLevelIds = new Set<number>(collectTopLevelFieldIds(fields))
+    const allIds = collectAllFieldIds(fields)
+    const allIdSet = new Set<number>()
+    for (const id of allIds) {
+      if (allIdSet.has(id)) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['fields'],
+          message: `duplicate field id: ${id}`,
+        })
+      }
+      allIdSet.add(id)
+    }
+
+    const maxFieldId = allIds.length > 0 ? Math.max(...allIds) : 1000
+    if (entity.field_id_seq <= maxFieldId) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['field_id_seq'],
+        message: `field_id_seq must be greater than max field id ${maxFieldId}`,
+      })
+    }
+
+    for (const [rowIndex, row] of (entity.layout ?? []).entries()) {
+      for (const [colIndex, fieldId] of row.entries()) {
+        if (!topLevelIds.has(fieldId)) {
+          ctx.addIssue({
+            code: z.ZodIssueCode.custom,
+            path: ['layout', rowIndex, colIndex],
+            message: `layout references unknown top-level field id ${fieldId}`,
+          })
+        }
+      }
+    }
+
+    for (const [fieldIndex, field] of fields.entries()) {
+      if (field.type !== 'subform' && field.children !== null) {
+        ctx.addIssue({
+          code: z.ZodIssueCode.custom,
+          path: ['fields', fieldIndex, 'children'],
+          message: 'only subform field can define children',
+        })
+      }
+      if (field.type === 'subform') {
+        const childIds = new Set<number>((field.children ?? []).map((child: any) => child.id))
+        for (const [rowIndex, row] of (field.layout ?? []).entries()) {
+          for (const [colIndex, fieldId] of row.entries()) {
+            if (!childIds.has(fieldId)) {
+              ctx.addIssue({
+                code: z.ZodIssueCode.custom,
+                path: ['fields', fieldIndex, 'layout', rowIndex, colIndex],
+                message: `subform layout references non-child field id ${fieldId}`,
+              })
+            }
+          }
+        }
+      }
+
+      if (field.type === 'lookup' || field.type === 'rollup') {
+        const localLinktoFieldId = field.options?.relation?.local_linkto_field_id
+        if (typeof localLinktoFieldId === 'number') {
+          const target = fields.find((item: any) => item.id === localLinktoFieldId)
+          if (!target || target.type !== 'linkto') {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              path: ['fields', fieldIndex, 'options', 'relation', 'local_linkto_field_id'],
+              message: 'local_linkto_field_id must reference a linkto field',
+            })
+          }
+        }
+      }
+
+      if (field.type === 'formula' || field.type === 'rollup') {
+        const formulaCode = field.type === 'formula'
+          ? field.options?.formula?.code
+          : field.options?.aggregation_formula?.code
+        for (const referencedFieldId of extractFormulaFieldIds(formulaCode)) {
+          if (!allIdSet.has(referencedFieldId)) {
+            ctx.addIssue({
+              code: z.ZodIssueCode.custom,
+              path: ['fields', fieldIndex, 'options'],
+              message: `formula references unknown field id ${referencedFieldId}`,
+            })
+          }
+        }
+      }
+    }
+  })
+
+export const EntitySaveReqVOSchemaOverride: z.ZodTypeAny = z.preprocess(normalizeEntitySaveInput, EntitySaveReqVOBaseSchema)
+
+const queryOrderSchema = z.object({
+  column: z.string().min(1),
+  order: z.string().min(1),
+}).strict()
+
+export const AppCreateByTenantsReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  icon_color: z.string().optional(),
+  icon_name: z.string().optional(),
+  name: z.string().min(1).max(20),
+}).strict()
+
+export const EntityQueryReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  limit: z.number().int().positive().optional(),
+  offset: z.number().int().min(0).optional(),
+  policy_id: z.string().optional(),
+  search: z.record(z.string(), z.any()).optional(),
+  sorts: z.array(queryOrderSchema).optional(),
+  view_mode: z.string().optional(),
+  viewMode: z.never().optional(),
+  withSubForm: z.boolean().optional(),
+}).strict()
+
+export const InsertReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  policy_id: z.string().optional(),
+  fields: z.record(z.string(), z.any()),
+}).strict().superRefine((body, ctx) => {
+  for (const key of Object.keys(body.fields ?? {})) {
+    if (!/^\d+$/.test(key)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['fields', key],
+        message: 'row fields must use numeric field ids as keys',
+      })
+    }
+  }
+})
+
+export const EntityUpdateReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  changed_fields: z.array(z.number().int().positive()).min(1),
+  data: z.record(z.string(), z.any()),
+  policy_id: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  fields: z.never().optional(),
+}).strict().superRefine((body, ctx) => {
+  const dataFieldIds = new Set<number>()
+  for (const key of Object.keys(body.data ?? {})) {
+    if (!/^\d+$/.test(key)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['data', key],
+        message: 'row data must use numeric field ids as keys',
+      })
+      continue
+    }
+    dataFieldIds.add(Number(key))
+  }
+  for (const [index, fieldId] of body.changed_fields.entries()) {
+    if (!dataFieldIds.has(fieldId)) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['changed_fields', index],
+        message: `changed_fields references ${fieldId}, but data does not contain that field id`,
+      })
+    }
+  }
+})
+
+const entitySelectionSortSchema = z.object({
+  column: z.string().min(1),
+  order: z.string().min(1),
+}).strict()
+
+const entitySelectionIdsSchema = z.object({
+  type: z.literal('ids'),
+  ids: z.array(z.number().int().positive()).min(1),
+  length: z.number().int().positive().optional(),
+  sorts: z.array(entitySelectionSortSchema).optional(),
+  condition: z.record(z.string(), z.any()).optional(),
+}).strict().superRefine((selection, ctx) => {
+  if (selection.length !== undefined && selection.length !== selection.ids.length) {
+    ctx.addIssue({
+      code: z.ZodIssueCode.custom,
+      path: ['length'],
+      message: 'length must match ids.length when provided',
+    })
+  }
+})
+
+const entitySelectionConditionSchema = z.object({
+  type: z.literal('condition'),
+  length: z.number().int().positive(),
+  condition: z.record(z.string(), z.any()).superRefine((condition, ctx) => {
+    if (!Object.keys(condition).length) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'condition selection requires a non-empty condition object',
+      })
+      return
+    }
+    if (condition.selectAll !== true) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        path: ['selectAll'],
+        message: 'condition selection must set selectAll to true',
+      })
+    }
+    const filterKeys = Object.keys(condition).filter((key) => key !== 'selectAll')
+    if (filterKeys.length === 0) {
+      return
+    }
+    const hasSupportedQueryKey = filterKeys.some((key) => key === 'q' || key === 'tab' || key.startsWith('filter_'))
+    if (!hasSupportedQueryKey) {
+      ctx.addIssue({
+        code: z.ZodIssueCode.custom,
+        message: 'condition selection extra keys must use q, tab, or filter_*',
+      })
+    }
+  }),
+  sorts: z.array(entitySelectionSortSchema).optional(),
+  ids: z.array(z.number().int().positive()).optional(),
+}).strict()
+
+const entitySelectionAllSchema = z.object({
+  type: z.literal('all'),
+  length: z.number().int().positive().optional(),
+  ids: z.array(z.number().int().positive()).optional(),
+  condition: z.record(z.string(), z.any()).optional(),
+  sorts: z.array(entitySelectionSortSchema).optional(),
+}).strict()
+
+const entitySelectionSchema = z.union([
+  entitySelectionIdsSchema,
+  entitySelectionConditionSchema,
+  entitySelectionAllSchema,
+])
+
+const entitySelectionLooseSchema = z.union([
+  entitySelectionSchema,
+  entitySelectionAllSchema,
+])
+
+export const EntitySelectionActionReqVOSchemaOverride: z.ZodTypeAny = z.lazy(() =>
+  z.object({
+    limit: z.number().int().positive().optional(),
+    offset: z.number().int().min(0).optional(),
+    policy_id: z.string().optional(),
+    selection: entitySelectionSchema,
+  }).strict(),
+)
+
+const bulkUpdateActionSchema = z.object({
+  type: z.string().min(1),
+  value: z.any().optional(),
+  text_search: z.string().optional(),
+  text_replace: z.string().optional(),
+  text_append: z.string().optional(),
+  text_prepend: z.string().optional(),
+  number_add: z.number().optional(),
+  number_mul: z.number().optional(),
+  number_sub: z.number().optional(),
+  datetime_add: z.number().optional(),
+  datetime_sub: z.number().optional(),
+}).strict().superRefine((action, ctx) => {
+  switch (action.type) {
+    case 'set':
+      if (!('value' in action)) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['value'], message: 'set action requires value' })
+      }
+      break
+    case 'text_replace':
+      if (!action.text_search) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_search'], message: 'text_replace requires text_search' })
+      }
+      if (!action.text_replace) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_replace'], message: 'text_replace requires text_replace' })
+      }
+      break
+    case 'text_append':
+      if (!action.text_append) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_append'], message: 'text_append requires text_append' })
+      }
+      break
+    case 'text_prepend':
+      if (!action.text_prepend) {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['text_prepend'], message: 'text_prepend requires text_prepend' })
+      }
+      break
+    case 'number_add':
+      if (typeof action.number_add !== 'number') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['number_add'], message: 'number_add requires number_add' })
+      }
+      break
+    case 'number_sub':
+      if (typeof action.number_sub !== 'number') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['number_sub'], message: 'number_sub requires number_sub' })
+      }
+      break
+    case 'number_mul':
+      if (typeof action.number_mul !== 'number') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['number_mul'], message: 'number_mul requires number_mul' })
+      }
+      break
+    case 'datetime_add':
+      if (typeof action.datetime_add !== 'number') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['datetime_add'], message: 'datetime_add requires datetime_add' })
+      }
+      break
+    case 'datetime_sub':
+      if (typeof action.datetime_sub !== 'number') {
+        ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['datetime_sub'], message: 'datetime_sub requires datetime_sub' })
+      }
+      break
+    case 'datetime_now':
+    case 'formula':
+      break
+    default:
+      ctx.addIssue({ code: z.ZodIssueCode.custom, path: ['type'], message: `unsupported bulk update action type: ${action.type}` })
+  }
+})
+
+export const EntityBulkUpdateReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  policy_id: z.string().optional(),
+  selection: entitySelectionSchema,
+  fields: z.array(z.object({
+    id: z.number().int().min(1001),
+    action: bulkUpdateActionSchema,
+  }).strict()).min(1),
+}).strict()
+
+export const EntityTagsSelectionReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  policy_id: z.string(),
+  selection: entitySelectionSchema,
+}).strict()
+
+export const EntityTagsBatchReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  policy_id: z.string(),
+  selection: entitySelectionSchema,
+  tag_names: z.array(z.string().min(1)).min(1),
+}).strict()
+
+export const EntityInvokeBatchOperatorReqVOSchemaOverride: z.ZodTypeAny = z.object({
+  id: z.string().min(1),
+  data: z.object({
+    action_id: z.string().min(1),
+    policy_id: z.string().optional(),
+    selection: entitySelectionLooseSchema,
+  }).strict(),
+  params: z.record(z.string(), z.any()).optional(),
+}).strict()