@naturalcycles/db-lib 10.39.0 → 10.40.0

package/dist/testing/commonDBTest.js

@@ -4,7 +4,7 @@ import { _deepFreeze, _filterObject, _pick } from '@naturalcycles/js-lib/object'
 import { pMap } from '@naturalcycles/js-lib/promise/pMap.js';
 import { CommonDBType } from '../commondb/common.db.js';
 import { DBQuery } from '../query/dbQuery.js';
-import { createTestItemDBM, createTestItemsDBM, TEST_TABLE, testItemBMJsonSchema, } from './test.model.js';
+import { createTestItemDBM, createTestItemsDBM, TEST_TABLE, testItemBMSchema, } from './test.model.js';
 export async function runCommonDBTest(db, quirks = {}) {
     // this is because vitest cannot be "required" from cjs
     const { test, expect } = await import('vitest');
@@ -19,7 +19,7 @@ export async function runCommonDBTest(db, quirks = {}) {
     // CREATE TABLE, DROP
     if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await db.createTable(TEST_TABLE, testItemBMJsonSchema, { dropIfExists: true });
+            await db.createTable(TEST_TABLE, testItemBMSchema.build(), { dropIfExists: true });
         });
     }
     if (support.queries) {

package/dist/testing/commonDaoTest.js

@@ -1,11 +1,11 @@
 import { _sortBy } from '@naturalcycles/js-lib/array/sort.js';
 import { localTime } from '@naturalcycles/js-lib/datetime/localTime.js';
 import { _deepCopy, _filterObject, _omit, _pick } from '@naturalcycles/js-lib/object';
-import { getJoiValidationFunction } from '@naturalcycles/nodejs-lib/joi';
+import { AjvSchema } from '@naturalcycles/nodejs-lib/ajv';
 import { Pipeline } from '@naturalcycles/nodejs-lib/stream';
 import { CommonDao } from '../commondao/common.dao.js';
 import { DBQuery } from '../query/dbQuery.js';
-import { createTestItemBM, createTestItemsBM, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, } from './test.model.js';
+import { createTestItemBM, createTestItemsBM, TEST_TABLE, testItemBMSchema } from './test.model.js';
 export async function runCommonDaoTest(db, quirks = {}) {
     // this is because vitest cannot be "required" from cjs
     const { test, expect } = await import('vitest');
@@ -13,7 +13,7 @@ export async function runCommonDaoTest(db, quirks = {}) {
     const dao = new CommonDao({
         table: TEST_TABLE,
         db,
-        validateBM: getJoiValidationFunction(testItemBMSchema),
+        validateBM: AjvSchema.create(testItemBMSchema).getValidationFunction(),
     });
     const items = createTestItemsBM(3);
     const itemsClone = _deepCopy(items);
@@ -29,7 +29,7 @@ export async function runCommonDaoTest(db, quirks = {}) {
     // CREATE TABLE, DROP
     if (support.createTable) {
         test('createTable, dropIfExists=true', async () => {
-            await dao.createTable(testItemBMJsonSchema, { dropIfExists: true });
+            await dao.createTable(testItemBMSchema.build(), { dropIfExists: true });
         });
     }
     if (support.queries) {

package/dist/testing/index.d.ts

@@ -4,6 +4,6 @@ import { runCommonDBTest } from './commonDBTest.js';
 import { runCommonKeyValueDaoTest } from './keyValueDaoTest.js';
 import { runCommonKeyValueDBTest } from './keyValueDBTest.js';
 import type { TestItemBM, TestItemDBM, TestItemTM } from './test.model.js';
-import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema } from './test.model.js';
+import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, testItemBMSchema, testItemTMSchema } from './test.model.js';
 export type { CommonDBImplementationQuirks, TestItemBM, TestItemDBM, TestItemTM };
-export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDaoTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, };
+export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDaoTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMSchema, testItemTMSchema, };

package/dist/testing/index.js

@@ -2,5 +2,5 @@ import { runCommonDaoTest } from './commonDaoTest.js';
 import { runCommonDBTest } from './commonDBTest.js';
 import { runCommonKeyValueDaoTest } from './keyValueDaoTest.js';
 import { runCommonKeyValueDBTest } from './keyValueDBTest.js';
-import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, } from './test.model.js';
-export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDaoTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMJsonSchema, testItemBMSchema, testItemTMSchema, };
+import { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, TEST_TABLE, testItemBMSchema, testItemTMSchema, } from './test.model.js';
+export { createTestItemBM, createTestItemDBM, createTestItemsBM, createTestItemsDBM, runCommonDaoTest, runCommonDBTest, runCommonKeyValueDaoTest, runCommonKeyValueDBTest, TEST_TABLE, testItemBMSchema, testItemTMSchema, };

package/dist/testing/test.model.d.ts

@@ -1,5 +1,4 @@
 import type { BaseDBEntity } from '@naturalcycles/js-lib/types';
-import { type ObjectSchema } from '@naturalcycles/nodejs-lib/joi';
 export declare const TEST_TABLE = "TEST_TABLE";
 export declare const TEST_TABLE_2 = "TEST_TABLE_2";
 export interface TestItemBM extends BaseDBEntity {
@@ -18,9 +17,8 @@ export interface TestItemTM {
     k1: string;
     even?: boolean;
 }
-export declare const testItemBMSchema: ObjectSchema<TestItemBM>;
-export declare const testItemTMSchema: ObjectSchema<TestItemTM>;
-export declare const testItemBMJsonSchema: any;
+export declare const testItemTMSchema: any;
+export declare const testItemBMSchema: any;
 export declare function createTestItemDBM(num?: number): TestItemDBM;
 export declare function createTestItemBM(num?: number): TestItemBM;
 export declare function createTestItemsDBM(count?: number): TestItemDBM[];

package/dist/testing/test.model.js

@@ -1,25 +1,13 @@
 import { _range } from '@naturalcycles/js-lib/array/range.js';
 import { j } from '@naturalcycles/nodejs-lib/ajv';
-import { baseDBEntitySchema, binarySchema, booleanSchema, numberSchema, objectSchema, stringSchema, } from '@naturalcycles/nodejs-lib/joi';
 const MOCK_TS_2018_06_21 = 1529539200;
 export const TEST_TABLE = 'TEST_TABLE';
 export const TEST_TABLE_2 = 'TEST_TABLE_2';
-export const testItemBMSchema = objectSchema({
-    k1: stringSchema,
-    k2: stringSchema.allow(null).optional(),
-    k3: numberSchema.optional(),
-    even: booleanSchema.optional(),
-    b1: binarySchema.optional(),
-    nested: objectSchema({
-        foo: numberSchema,
-    }).optional(),
-}).concat(baseDBEntitySchema);
-export const testItemTMSchema = objectSchema({
-    k1: stringSchema,
-    even: booleanSchema.optional(),
+export const testItemTMSchema = j.object({
+    k1: j.string(),
+    even: j.boolean().optional(),
 });
-export const testItemBMJsonSchema = j.object
-    .dbEntity({
+export const testItemBMSchema = j.object.dbEntity({
     // todo: figure out how to not copy-paste these 3 fields
     id: j.string(), // todo: not strictly needed here
     created: j.number().integer().unixTimestamp(),
@@ -30,8 +18,7 @@ export const testItemBMJsonSchema = j.object
     even: j.boolean().optional(),
     b1: j.buffer().optional(),
     nested: j.object.infer({ foo: j.number() }).optional(),
-})
-    .build();
+});
 export function createTestItemDBM(num = 1) {
     return {
         id: `id${num}`,

package/dist/validation/index.d.ts

@@ -1,9 +1,9 @@
-import { type ObjectSchema, type StringSchema } from '@naturalcycles/nodejs-lib/joi';
-import type { CommonDBOptions, CommonDBSaveOptions } from '../db.model.js';
-import type { DBQuery, DBQueryFilter, DBQueryFilterOperator, DBQueryOrder } from '../query/dbQuery.js';
-export declare const commonDBOptionsSchema: ObjectSchema<CommonDBOptions>;
-export declare const commonDBSaveOptionsSchema: ObjectSchema<CommonDBSaveOptions<any>>;
-export declare const dbQueryFilterOperatorSchema: StringSchema<DBQueryFilterOperator>;
-export declare const dbQueryFilterSchema: ObjectSchema<DBQueryFilter<any>>;
-export declare const dbQueryOrderSchema: ObjectSchema<DBQueryOrder<any>>;
-export declare const dbQuerySchema: ObjectSchema<DBQuery<any>>;
+import type { ObjectWithId } from '@naturalcycles/js-lib/types';
+import { type JsonSchemaObjectBuilder } from '@naturalcycles/nodejs-lib/ajv';
+import type { CommonDBOptions } from '../db.model.js';
+export declare const commonDBOptionsSchema: () => JsonSchemaObjectBuilder<CommonDBOptions, CommonDBOptions>;
+export declare const commonDBSaveOptionsSchema: <ROW extends ObjectWithId>() => any;
+export declare const dbQueryFilterOperatorSchema: any;
+export declare const dbQueryFilterSchema: <ROW extends ObjectWithId>() => any;
+export declare const dbQueryOrderSchema: <ROW extends ObjectWithId>() => any;
+export declare const dbQuerySchema: <ROW extends ObjectWithId>() => any;

package/dist/validation/index.js

@@ -1,29 +1,36 @@
-import { anySchema, arraySchema, booleanSchema, integerSchema, Joi, objectSchema, stringSchema, } from '@naturalcycles/nodejs-lib/joi';
-import { dbQueryFilterOperatorValues } from '../query/dbQuery.js';
-export const commonDBOptionsSchema = objectSchema({
-    ['onlyCache']: booleanSchema.optional(),
-    ['skipCache']: booleanSchema.optional(),
+import { j, JsonSchemaAnyBuilder, } from '@naturalcycles/nodejs-lib/ajv';
+import { dbQueryFilterOperatorValues, } from '../query/dbQuery.js';
+// oxlint-disable typescript/explicit-function-return-type
+// DBTransaction schema - validates presence without deep validation
+const dbTransactionSchema = j.object.any().castAs();
+// Schema that accepts any value (string, number, boolean, object, array, null)
+const anyValueSchema = new JsonSchemaAnyBuilder({});
+export const commonDBOptionsSchema = () => j.object({
+    tx: dbTransactionSchema.optional(),
 });
-export const commonDBSaveOptionsSchema = objectSchema({
-    excludeFromIndexes: arraySchema(stringSchema).optional(),
-}).concat(commonDBOptionsSchema);
-export const dbQueryFilterOperatorSchema = Joi.string().valid(...dbQueryFilterOperatorValues);
-export const dbQueryFilterSchema = objectSchema({
-    name: stringSchema,
+export const commonDBSaveOptionsSchema = () => j.object({
+    tx: dbTransactionSchema.optional(),
+    excludeFromIndexes: j.array(j.string().castAs()).optional(),
+    saveMethod: j.enum(['upsert', 'insert', 'update']).optional(),
+    assignGeneratedIds: j.boolean().optional(),
+});
+export const dbQueryFilterOperatorSchema = j.enum(dbQueryFilterOperatorValues);
+export const dbQueryFilterSchema = () => j.object({
+    name: j.string().castAs(),
     op: dbQueryFilterOperatorSchema,
-    val: anySchema,
+    val: anyValueSchema,
 });
-export const dbQueryOrderSchema = objectSchema({
-    name: stringSchema,
-    descending: booleanSchema.optional(),
+export const dbQueryOrderSchema = () => j.object({
+    name: j.string().castAs(),
+    descending: j.boolean().optional(),
 });
-export const dbQuerySchema = objectSchema({
-    table: stringSchema,
-    _filters: arraySchema(dbQueryFilterSchema).optional(),
-    _limitValue: integerSchema.min(0).optional(),
-    _offsetValue: integerSchema.min(0).optional(),
-    _orders: arraySchema(dbQueryOrderSchema).optional(),
-    _startCursor: stringSchema.optional(),
-    _endCursor: stringSchema.optional(),
-    _selectedFieldNames: arraySchema(stringSchema).optional(),
+export const dbQuerySchema = () => j.object.infer({
+    table: j.string(),
+    _filters: j.array(dbQueryFilterSchema()).optional(),
+    _limitValue: j.number().integer().min(0).optional(),
+    _offsetValue: j.number().integer().min(0).optional(),
+    _orders: j.array(dbQueryOrderSchema()).optional(),
+    _startCursor: j.string().optional(),
+    _endCursor: j.string().optional(),
+    _selectedFieldNames: j.array(j.string().castAs()).optional(),
 });

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/db-lib",
   "type": "module",
-  "version": "10.39.0",
+  "version": "10.40.0",
   "dependencies": {
     "@naturalcycles/js-lib": "^15",
     "@naturalcycles/nodejs-lib": "^15"

package/src/testing/commonDBTest.ts

@@ -10,7 +10,7 @@ import {
   createTestItemDBM,
   createTestItemsDBM,
   TEST_TABLE,
-  testItemBMJsonSchema,
+  testItemBMSchema,
 } from './test.model.js'
 
 /**
@@ -49,7 +49,7 @@ export async function runCommonDBTest(
   // CREATE TABLE, DROP
   if (support.createTable) {
     test('createTable, dropIfExists=true', async () => {
-      await db.createTable(TEST_TABLE, testItemBMJsonSchema, { dropIfExists: true })
+      await db.createTable(TEST_TABLE, testItemBMSchema.build(), { dropIfExists: true })
     })
   }
 

package/src/testing/commonDaoTest.ts

@@ -1,20 +1,14 @@
 import { _sortBy } from '@naturalcycles/js-lib/array/sort.js'
 import { localTime } from '@naturalcycles/js-lib/datetime/localTime.js'
 import { _deepCopy, _filterObject, _omit, _pick } from '@naturalcycles/js-lib/object'
-import { getJoiValidationFunction } from '@naturalcycles/nodejs-lib/joi'
+import { AjvSchema } from '@naturalcycles/nodejs-lib/ajv'
 import { Pipeline } from '@naturalcycles/nodejs-lib/stream'
 import { CommonDao } from '../commondao/common.dao.js'
 import type { CommonDB } from '../commondb/common.db.js'
 import { DBQuery } from '../query/dbQuery.js'
 import type { CommonDBImplementationQuirks } from './commonDBTest.js'
 import type { TestItemBM } from './test.model.js'
-import {
-  createTestItemBM,
-  createTestItemsBM,
-  TEST_TABLE,
-  testItemBMJsonSchema,
-  testItemBMSchema,
-} from './test.model.js'
+import { createTestItemBM, createTestItemsBM, TEST_TABLE, testItemBMSchema } from './test.model.js'
 
 export async function runCommonDaoTest(
   db: CommonDB,
@@ -27,7 +21,7 @@ export async function runCommonDaoTest(
   const dao = new CommonDao({
     table: TEST_TABLE,
     db,
-    validateBM: getJoiValidationFunction(testItemBMSchema),
+    validateBM: AjvSchema.create(testItemBMSchema).getValidationFunction(),
   })
 
   const items = createTestItemsBM(3)
@@ -47,7 +41,7 @@ export async function runCommonDaoTest(
   // CREATE TABLE, DROP
   if (support.createTable) {
     test('createTable, dropIfExists=true', async () => {
-      await dao.createTable(testItemBMJsonSchema, { dropIfExists: true })
+      await dao.createTable(testItemBMSchema.build(), { dropIfExists: true })
     })
   }
 

package/src/testing/index.ts

@@ -10,7 +10,6 @@ import {
   createTestItemsBM,
   createTestItemsDBM,
   TEST_TABLE,
-  testItemBMJsonSchema,
   testItemBMSchema,
   testItemTMSchema,
 } from './test.model.js'
@@ -27,7 +26,6 @@ export {
   runCommonKeyValueDaoTest,
   runCommonKeyValueDBTest,
   TEST_TABLE,
-  testItemBMJsonSchema,
   testItemBMSchema,
   testItemTMSchema,
 }

package/src/testing/test.model.ts

@@ -1,15 +1,6 @@
 import { _range } from '@naturalcycles/js-lib/array/range.js'
 import type { BaseDBEntity, UnixTimestamp } from '@naturalcycles/js-lib/types'
 import { j } from '@naturalcycles/nodejs-lib/ajv'
-import {
-  baseDBEntitySchema,
-  binarySchema,
-  booleanSchema,
-  numberSchema,
-  type ObjectSchema,
-  objectSchema,
-  stringSchema,
-} from '@naturalcycles/nodejs-lib/joi'
 
 const MOCK_TS_2018_06_21 = 1529539200 as UnixTimestamp
 
@@ -34,36 +25,23 @@ export interface TestItemTM {
   even?: boolean
 }
 
-export const testItemBMSchema: ObjectSchema<TestItemBM> = objectSchema<TestItemBM>({
-  k1: stringSchema,
-  k2: stringSchema.allow(null).optional(),
-  k3: numberSchema.optional(),
-  even: booleanSchema.optional(),
-  b1: binarySchema.optional(),
-  nested: objectSchema({
-    foo: numberSchema,
-  }).optional(),
-}).concat(baseDBEntitySchema as any)
-
-export const testItemTMSchema: ObjectSchema<TestItemTM> = objectSchema<TestItemTM>({
-  k1: stringSchema,
-  even: booleanSchema.optional(),
+export const testItemTMSchema = j.object<TestItemTM>({
+  k1: j.string(),
+  even: j.boolean().optional(),
 })
 
-export const testItemBMJsonSchema = j.object
-  .dbEntity<TestItemBM>({
-    // todo: figure out how to not copy-paste these 3 fields
-    id: j.string(), // todo: not strictly needed here
-    created: j.number().integer().unixTimestamp(),
-    updated: j.number().integer().unixTimestamp(),
-    k1: j.string(),
-    k2: j.string().nullable().optional(),
-    k3: j.number().optional(),
-    even: j.boolean().optional(),
-    b1: j.buffer().optional(),
-    nested: j.object.infer({ foo: j.number() }).optional(),
-  })
-  .build()
+export const testItemBMSchema = j.object.dbEntity<TestItemBM>({
+  // todo: figure out how to not copy-paste these 3 fields
+  id: j.string(), // todo: not strictly needed here
+  created: j.number().integer().unixTimestamp(),
+  updated: j.number().integer().unixTimestamp(),
+  k1: j.string(),
+  k2: j.string().nullable().optional(),
+  k3: j.number().optional(),
+  even: j.boolean().optional(),
+  b1: j.buffer().optional(),
+  nested: j.object.infer({ foo: j.number() }).optional(),
+})
 
 export function createTestItemDBM(num = 1): TestItemDBM {
   return {

package/src/validation/index.ts

@@ -1,57 +1,63 @@
+import type { ObjectWithId } from '@naturalcycles/js-lib/types'
 import {
-  anySchema,
-  arraySchema,
-  booleanSchema,
-  integerSchema,
-  Joi,
-  type ObjectSchema,
-  objectSchema,
-  type StringSchema,
-  stringSchema,
-} from '@naturalcycles/nodejs-lib/joi'
-import type { CommonDBOptions, CommonDBSaveOptions } from '../db.model.js'
-import type {
-  DBQuery,
-  DBQueryFilter,
-  DBQueryFilterOperator,
-  DBQueryOrder,
+  j,
+  JsonSchemaAnyBuilder,
+  type JsonSchemaObjectBuilder,
+} from '@naturalcycles/nodejs-lib/ajv'
+import type { CommonDBOptions, CommonDBSaveOptions, DBTransaction } from '../db.model.js'
+import {
+  type DBQueryFilter,
+  dbQueryFilterOperatorValues,
+  type DBQueryOrder,
 } from '../query/dbQuery.js'
-import { dbQueryFilterOperatorValues } from '../query/dbQuery.js'
-
-export const commonDBOptionsSchema: ObjectSchema<CommonDBOptions> = objectSchema<CommonDBOptions>({
-  ['onlyCache' as any]: booleanSchema.optional(),
-  ['skipCache' as any]: booleanSchema.optional(),
-})
-
-export const commonDBSaveOptionsSchema: ObjectSchema<CommonDBSaveOptions<any>> = objectSchema<
-  CommonDBSaveOptions<any>
->({
-  excludeFromIndexes: arraySchema(stringSchema).optional(),
-}).concat(commonDBOptionsSchema)
-
-export const dbQueryFilterOperatorSchema: StringSchema<DBQueryFilterOperator> =
-  Joi.string<DBQueryFilterOperator>().valid(...dbQueryFilterOperatorValues)
-
-export const dbQueryFilterSchema: ObjectSchema<DBQueryFilter<any>> = objectSchema<
-  DBQueryFilter<any>
->({
-  name: stringSchema,
-  op: dbQueryFilterOperatorSchema,
-  val: anySchema,
-})
-
-export const dbQueryOrderSchema: ObjectSchema<DBQueryOrder<any>> = objectSchema<DBQueryOrder<any>>({
-  name: stringSchema,
-  descending: booleanSchema.optional(),
-})
-
-export const dbQuerySchema: ObjectSchema<DBQuery<any>> = objectSchema<DBQuery<any>>({
-  table: stringSchema,
-  _filters: arraySchema(dbQueryFilterSchema).optional(),
-  _limitValue: integerSchema.min(0).optional(),
-  _offsetValue: integerSchema.min(0).optional(),
-  _orders: arraySchema(dbQueryOrderSchema).optional(),
-  _startCursor: stringSchema.optional(),
-  _endCursor: stringSchema.optional(),
-  _selectedFieldNames: arraySchema(stringSchema).optional(),
-})
+
+// oxlint-disable typescript/explicit-function-return-type
+
+// DBTransaction schema - validates presence without deep validation
+const dbTransactionSchema = j.object.any().castAs<DBTransaction>()
+
+// Schema that accepts any value (string, number, boolean, object, array, null)
+const anyValueSchema = new JsonSchemaAnyBuilder<any, any, false>({})
+
+export const commonDBOptionsSchema = (): JsonSchemaObjectBuilder<
+  CommonDBOptions,
+  CommonDBOptions
+> =>
+  j.object<CommonDBOptions>({
+    tx: dbTransactionSchema.optional(),
+  })
+
+export const commonDBSaveOptionsSchema = <ROW extends ObjectWithId>() =>
+  j.object<CommonDBSaveOptions<ROW>>({
+    tx: dbTransactionSchema.optional(),
+    excludeFromIndexes: j.array(j.string().castAs<keyof ROW>()).optional(),
+    saveMethod: j.enum(['upsert', 'insert', 'update'] as const).optional(),
+    assignGeneratedIds: j.boolean().optional(),
+  })
+
+export const dbQueryFilterOperatorSchema = j.enum(dbQueryFilterOperatorValues)
+
+export const dbQueryFilterSchema = <ROW extends ObjectWithId>() =>
+  j.object<DBQueryFilter<ROW>>({
+    name: j.string().castAs<keyof ROW>(),
+    op: dbQueryFilterOperatorSchema,
+    val: anyValueSchema,
+  })
+
+export const dbQueryOrderSchema = <ROW extends ObjectWithId>() =>
+  j.object<DBQueryOrder<ROW>>({
+    name: j.string().castAs<keyof ROW>(),
+    descending: j.boolean().optional(),
+  })
+
+export const dbQuerySchema = <ROW extends ObjectWithId>() =>
+  j.object.infer({
+    table: j.string(),
+    _filters: j.array(dbQueryFilterSchema<ROW>()).optional(),
+    _limitValue: j.number().integer().min(0).optional(),
+    _offsetValue: j.number().integer().min(0).optional(),
+    _orders: j.array(dbQueryOrderSchema<ROW>()).optional(),
+    _startCursor: j.string().optional(),
+    _endCursor: j.string().optional(),
+    _selectedFieldNames: j.array(j.string().castAs<keyof ROW>()).optional(),
+  })