@naturalcycles/datastore-lib 4.16.1 → 4.18.0

package/dist/datastore.db.d.ts

@@ -1,9 +1,10 @@
-import type { Datastore, Key, Transaction } from '@google-cloud/datastore';
+import type { Key, Transaction } from '@google-cloud/datastore';
+import { Datastore } from '@google-cloud/datastore';
 import type { CommonDB, CommonDBOptions, CommonDBReadOptions, CommonDBSaveOptions, CommonDBSupport, CommonDBTransactionOptions, DBQuery, DBTransaction, DBTransactionFn, RunQueryResult } from '@naturalcycles/db-lib';
 import { BaseCommonDB } from '@naturalcycles/db-lib';
-import type { JsonSchemaObject, JsonSchemaRootObject } from '@naturalcycles/js-lib/json-schema';
 import type { CommonLogger } from '@naturalcycles/js-lib/log';
 import { type ObjectWithId, type StringMap } from '@naturalcycles/js-lib/types';
+import type { JsonSchema } from '@naturalcycles/nodejs-lib/ajv';
 import { Pipeline } from '@naturalcycles/nodejs-lib/stream';
 import type { DatastoreDBCfg, DatastoreDBOptions, DatastoreDBReadOptions, DatastoreDBSaveOptions, DatastoreDBStreamOptions, DatastorePropertyStats, DatastoreStats } from './datastore.model.js';
 /**
@@ -22,9 +23,7 @@ export declare class DatastoreDB extends BaseCommonDB implements CommonDB {
      * Datastore.KEY
      */
     protected KEY: symbol;
-    ds(): Promise<Datastore>;
-    private getPropertyFilter;
-    private getDatastoreLib;
+    ds(): Datastore;
     ping(): Promise<void>;
     getByIds<ROW extends ObjectWithId>(table: string, ids: string[], opt?: DatastoreDBReadOptions): Promise<ROW[]>;
     multiGet<ROW extends ObjectWithId>(map: StringMap<string[]>, opt?: DatastoreDBReadOptions): Promise<StringMap<ROW[]>>;
@@ -58,9 +57,9 @@ export declare class DatastoreDB extends BaseCommonDB implements CommonDB {
     key(ds: Datastore, kind: string, id: string): Key;
     private getDsKey;
     private getIdFromKey;
-    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchemaObject<ROW>): Promise<void>;
+    createTable<ROW extends ObjectWithId>(_table: string, _schema: JsonSchema<ROW>): Promise<void>;
     getTables(): Promise<string[]>;
-    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchemaRootObject<ROW>>;
+    getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchema<ROW>>;
     private getPRetryOptions;
     /**
      * Silently rollback the transaction.

package/dist/datastore.db.js

@@ -1,3 +1,4 @@
+import { Datastore, PropertyFilter } from '@google-cloud/datastore';
 import { BaseCommonDB, commonDBFullSupport } from '@naturalcycles/db-lib';
 import { _round } from '@naturalcycles/js-lib';
 import { _chunk } from '@naturalcycles/js-lib/array/array.util.js';
@@ -62,10 +63,9 @@ export class DatastoreDB extends BaseCommonDB {
      */
     KEY;
     // @memo() // not used to be able to connect to many DBs in the same server instance
-    async ds() {
+    ds() {
         if (!this.cachedDatastore) {
             _assert(process.env['APP_ENV'] !== 'test', 'DatastoreDB cannot be used in Test env, please use InMemoryDB');
-            const DS = (await this.getDatastoreLib()).Datastore;
             this.cfg.projectId ||= this.cfg.credentials?.project_id || process.env['GOOGLE_CLOUD_PROJECT'];
             if (this.cfg.projectId) {
                 this.cfg.logger.log(`DatastoreDB connected to ${boldWhite(this.cfg.projectId)}`);
@@ -76,26 +76,18 @@ export class DatastoreDB extends BaseCommonDB {
             if (this.cfg.grpc) {
                 this.cfg.logger.log('!!! DatastoreDB using custom grpc !!!');
             }
-            this.cachedDatastore = new DS(this.cfg);
+            this.cachedDatastore = new Datastore(this.cfg);
             this.KEY = this.cachedDatastore.KEY;
         }
         return this.cachedDatastore;
     }
-    async getPropertyFilter() {
-        return (await this.getDatastoreLib()).PropertyFilter;
-    }
-    async getDatastoreLib() {
-        // Lazy-loading
-        const lib = await import('@google-cloud/datastore');
-        return lib;
-    }
     async ping() {
         await this.getAllStats();
     }
     async getByIds(table, ids, opt = {}) {
         if (!ids.length)
             return [];
-        let ds = await this.ds();
+        let ds = this.ds();
         const keys = ids.map(id => this.key(ds, table, id));
         let rows;
         const dsOpt = this.getRunQueryOptions(opt);
@@ -115,9 +107,7 @@ export class DatastoreDB extends BaseCommonDB {
                 }
                 this.cfg.logger.log(`datastore recreated on timeout (${_ms(this.cfg.timeout)}) while loading ${table}`);
                 // This is to debug "GCP Datastore Timeout issue"
-                const datastoreLib = await this.getDatastoreLib();
-                const DS = datastoreLib.Datastore;
-                ds = this.cachedDatastore = new DS(this.cfg);
+                ds = this.cachedDatastore = new Datastore(this.cfg);
                 // Second try (will throw)
                 try {
                     const r = await pRetry(() => (opt.tx?.tx || ds).get(keys, dsOpt), {
@@ -150,7 +140,7 @@ export class DatastoreDB extends BaseCommonDB {
     }
     async multiGet(map, opt = {}) {
         const result = {};
-        const ds = await this.ds();
+        const ds = this.ds();
         const dsOpt = this.getRunQueryOptions(opt);
         const keys = [];
         for (const [table, ids] of _stringMapEntries(map)) {
@@ -182,8 +172,8 @@ export class DatastoreDB extends BaseCommonDB {
                 rows: await this.getByIds(dbQuery.table, ids, opt),
             };
         }
-        const ds = await this.ds();
-        const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table), await this.getPropertyFilter());
+        const ds = this.ds();
+        const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table));
         const dsOpt = this.getRunQueryOptions(opt);
         const qr = await this.runDatastoreQuery(q, dsOpt);
         // Special case when projection query didn't specify 'id'
@@ -193,15 +183,15 @@ export class DatastoreDB extends BaseCommonDB {
         return qr;
     }
     async runQueryCount(dbQuery, opt = {}) {
-        const ds = await this.ds();
-        const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table), await this.getPropertyFilter());
+        const ds = this.ds();
+        const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table));
         const aq = ds.createAggregationQuery(q).count('count');
         const dsOpt = this.getRunQueryOptions(opt);
         const [entities] = await ds.runAggregationQuery(aq, dsOpt);
         return entities[0]?.count;
     }
     async runDatastoreQuery(q, dsOpt) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const [entities, queryResult] = await ds.runQuery(q, dsOpt);
         const rows = entities.map(e => this.mapId(e));
         return {
@@ -211,8 +201,8 @@ export class DatastoreDB extends BaseCommonDB {
     }
     streamQuery(dbQuery, _opt) {
         return Pipeline.fromAsyncReadable(async () => {
-            const ds = await this.ds();
-            const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table), await this.getPropertyFilter());
+            const ds = this.ds();
+            const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table));
             const opt = {
                 logger: this.cfg.logger,
                 ...this.cfg.streamOptions,
@@ -228,7 +218,7 @@ export class DatastoreDB extends BaseCommonDB {
      * Returns saved entities with generated id/updated/created (non-mutating!)
      */
     async saveBatch(table, rows, opt = {}) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const entities = rows.map(obj => this.toDatastoreEntity(ds, table, obj, opt.excludeFromIndexes));
         const method = methodMap[opt.saveMethod || 'upsert'] || 'save';
         const save = pRetryFn(async (batch) => {
@@ -264,8 +254,8 @@ export class DatastoreDB extends BaseCommonDB {
             const ids = idFilter.op === '==' ? [idFilter.val] : idFilter.val;
             return await this.deleteByIds(q.table, ids, opt);
         }
-        const ds = await this.ds();
-        const datastoreQuery = dbQueryToDatastoreQuery(q.select([]), ds.createQuery(q.table), await this.getPropertyFilter());
+        const ds = this.ds();
+        const datastoreQuery = dbQueryToDatastoreQuery(q.select([]), ds.createQuery(q.table));
         const dsOpt = this.getRunQueryOptions(opt);
         const { rows } = await this.runDatastoreQuery(datastoreQuery, dsOpt);
         return await this.deleteByIds(q.table, rows.map(obj => obj.id), opt);
@@ -275,7 +265,7 @@ export class DatastoreDB extends BaseCommonDB {
      * regardless if they were actually deleted or not.
      */
     async deleteByIds(table, ids, opt = {}) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const keys = ids.map(id => this.key(ds, table, id));
         const retryOptions = this.getPRetryOptions(`DatastoreLib.deleteByIds(${table})`);
         await pMap(_chunk(keys, MAX_ITEMS), 
@@ -290,7 +280,7 @@ export class DatastoreDB extends BaseCommonDB {
         return ids.length;
     }
     async multiDelete(map, opt = {}) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const keys = [];
         for (const [table, ids] of _stringMapEntries(map)) {
             keys.push(...ids.map(id => this.key(ds, table, id)));
@@ -308,7 +298,7 @@ export class DatastoreDB extends BaseCommonDB {
         return keys.length;
     }
     async createTransaction(opt = {}) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const { readOnly } = opt;
         const datastoreTx = ds.transaction({
             readOnly,
@@ -317,7 +307,7 @@ export class DatastoreDB extends BaseCommonDB {
         return new DatastoreDBTransaction(this, datastoreTx);
     }
     async runInTransaction(fn, opt = {}) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const { readOnly } = opt;
         const datastoreTx = ds.transaction({
             readOnly,
@@ -334,7 +324,7 @@ export class DatastoreDB extends BaseCommonDB {
         }
     }
     async getAllStats() {
-        const ds = await this.ds();
+        const ds = this.ds();
         const q = ds.createQuery('__Stat_Kind__');
         const [statsArray] = await ds.runQuery(q);
         return statsArray || [];
@@ -343,12 +333,11 @@ export class DatastoreDB extends BaseCommonDB {
      * Returns undefined e.g when Table is non-existing
      */
     async getStats(table) {
-        const ds = await this.ds();
-        const propertyFilter = await this.getPropertyFilter();
+        const ds = this.ds();
         const q = ds
             .createQuery('__Stat_Kind__')
             // .filter('kind_name', table)
-            .filter(new propertyFilter('kind_name', '=', table))
+            .filter(new PropertyFilter('kind_name', '=', table))
             .limit(1);
         const [statsArray] = await ds.runQuery(q);
         const [stats] = statsArray;
@@ -359,11 +348,11 @@ export class DatastoreDB extends BaseCommonDB {
         return stats?.count;
     }
     async getTableProperties(table) {
-        const ds = await this.ds();
+        const ds = this.ds();
         const q = ds
             .createQuery('__Stat_PropertyType_PropertyName_Kind__')
             // .filter('kind_name', table)
-            .filter(new (await this.getPropertyFilter())('kind_name', '=', table));
+            .filter(new PropertyFilter('kind_name', '=', table));
         const [stats] = await ds.runQuery(q);
         return stats;
     }

package/dist/datastore.model.d.ts

@@ -106,12 +106,12 @@ export interface DatastoreStats {
 export declare enum DatastoreType {
     Blob = "Blob",
     Text = "Text",
-    String = "String",// eslint-disable-line id-blacklist
+    String = "String",// eslint-disable-line id-denylist
     EmbeddedEntity = "EmbeddedEntity",
     Float = "Float",
     Integer = "Integer",
     DATE_TIME = "Date/Time",
-    Boolean = "Boolean",// eslint-disable-line id-blacklist
+    Boolean = "Boolean",// eslint-disable-line id-denylist
     NULL = "NULL"
 }
 export interface DatastorePropertyStats {

package/dist/query.util.d.ts

@@ -1,4 +1,4 @@
-import type { PropertyFilter, Query } from '@google-cloud/datastore';
+import { type Query } from '@google-cloud/datastore';
 import type { DBQuery } from '@naturalcycles/db-lib';
 import type { ObjectWithId } from '@naturalcycles/js-lib/types';
-export declare function dbQueryToDatastoreQuery<ROW extends ObjectWithId>(dbQuery: Readonly<DBQuery<ROW>>, emptyQuery: Query, propertyFilterClass: typeof PropertyFilter): Query;
+export declare function dbQueryToDatastoreQuery<ROW extends ObjectWithId>(dbQuery: Readonly<DBQuery<ROW>>, emptyQuery: Query): Query;

package/dist/query.util.js

@@ -1,3 +1,4 @@
+import { PropertyFilter } from '@google-cloud/datastore';
 const FNAME_MAP = {
     id: '__key__',
 };
@@ -6,7 +7,7 @@ const OP_MAP = {
     in: 'IN',
     'not-in': 'NOT_IN',
 };
-export function dbQueryToDatastoreQuery(dbQuery, emptyQuery, propertyFilterClass) {
+export function dbQueryToDatastoreQuery(dbQuery, emptyQuery) {
     let q = emptyQuery;
     // filter
     for (const f of dbQuery._filters) {
@@ -20,7 +21,7 @@ export function dbQueryToDatastoreQuery(dbQuery, emptyQuery, propertyFilterClass
         let { op, val } = f;
         if (val === undefined)
             val = null;
-        q = q.filter(new propertyFilterClass(f.name, OP_MAP[op] || op, val));
+        q = q.filter(new PropertyFilter(f.name, OP_MAP[op] || op, val));
     }
     // limit
     q = q.limit(dbQuery._limitValue || 0);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@naturalcycles/datastore-lib",
   "type": "module",
-  "version": "4.16.1",
+  "version": "4.18.0",
   "description": "Opinionated library to work with Google Datastore, implements CommonDB",
   "dependencies": {
     "@google-cloud/datastore": "^10",

package/src/datastore.db.ts

@@ -1,4 +1,5 @@
-import type { Datastore, Key, PropertyFilter, Query, Transaction } from '@google-cloud/datastore'
+import type { Key, Query, Transaction } from '@google-cloud/datastore'
+import { Datastore, PropertyFilter } from '@google-cloud/datastore'
 import type { RunQueryOptions } from '@google-cloud/datastore/build/src/query.js'
 import type {
   CommonDB,
@@ -19,15 +20,6 @@ import { _chunk } from '@naturalcycles/js-lib/array/array.util.js'
 import { _ms } from '@naturalcycles/js-lib/datetime/time.util.js'
 import { _assert } from '@naturalcycles/js-lib/error/assert.js'
 import { _errorDataAppend, TimeoutError } from '@naturalcycles/js-lib/error/error.util.js'
-import type {
-  JsonSchemaAny,
-  JsonSchemaBoolean,
-  JsonSchemaNull,
-  JsonSchemaNumber,
-  JsonSchemaObject,
-  JsonSchemaRootObject,
-  JsonSchemaString,
-} from '@naturalcycles/js-lib/json-schema'
 import type { CommonLogger } from '@naturalcycles/js-lib/log'
 import { _omit } from '@naturalcycles/js-lib/object/object.util.js'
 import type { PRetryOptions } from '@naturalcycles/js-lib/promise'
@@ -40,6 +32,7 @@ import {
   type ObjectWithId,
   type StringMap,
 } from '@naturalcycles/js-lib/types'
+import type { JsonSchema } from '@naturalcycles/nodejs-lib/ajv'
 import { boldWhite } from '@naturalcycles/nodejs-lib/colors'
 import { Pipeline } from '@naturalcycles/nodejs-lib/stream'
 import type {
@@ -113,14 +106,13 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
   protected KEY!: symbol
 
   // @memo() // not used to be able to connect to many DBs in the same server instance
-  async ds(): Promise<Datastore> {
+  ds(): Datastore {
     if (!this.cachedDatastore) {
       _assert(
         process.env['APP_ENV'] !== 'test',
         'DatastoreDB cannot be used in Test env, please use InMemoryDB',
       )
 
-      const DS = (await this.getDatastoreLib()).Datastore as typeof Datastore
       this.cfg.projectId ||= this.cfg.credentials?.project_id || process.env['GOOGLE_CLOUD_PROJECT']
 
       if (this.cfg.projectId) {
@@ -133,23 +125,13 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
         this.cfg.logger.log('!!! DatastoreDB using custom grpc !!!')
       }
 
-      this.cachedDatastore = new DS(this.cfg)
+      this.cachedDatastore = new Datastore(this.cfg)
       this.KEY = this.cachedDatastore.KEY
     }
 
     return this.cachedDatastore
   }
 
-  private async getPropertyFilter(): Promise<typeof PropertyFilter> {
-    return (await this.getDatastoreLib()).PropertyFilter
-  }
-
-  private async getDatastoreLib(): Promise<any> {
-    // Lazy-loading
-    const lib = await import('@google-cloud/datastore')
-    return lib
-  }
-
   override async ping(): Promise<void> {
     await this.getAllStats()
   }
@@ -160,7 +142,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     opt: DatastoreDBReadOptions = {},
   ): Promise<ROW[]> {
     if (!ids.length) return []
-    let ds = await this.ds()
+    let ds = this.ds()
     const keys = ids.map(id => this.key(ds, table, id))
     let rows: any[]
 
@@ -188,9 +170,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
         )
 
         // This is to debug "GCP Datastore Timeout issue"
-        const datastoreLib = await this.getDatastoreLib()
-        const DS = datastoreLib.Datastore as typeof Datastore
-        ds = this.cachedDatastore = new DS(this.cfg)
+        ds = this.cachedDatastore = new Datastore(this.cfg)
 
         // Second try (will throw)
         try {
@@ -235,7 +215,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     opt: DatastoreDBReadOptions = {},
   ): Promise<StringMap<ROW[]>> {
     const result: StringMap<ROW[]> = {}
-    const ds = await this.ds()
+    const ds = this.ds()
     const dsOpt = this.getRunQueryOptions(opt)
     const keys: Key[] = []
     for (const [table, ids] of _stringMapEntries(map)) {
@@ -278,12 +258,8 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
       }
     }
 
-    const ds = await this.ds()
-    const q = dbQueryToDatastoreQuery(
-      dbQuery,
-      ds.createQuery(dbQuery.table),
-      await this.getPropertyFilter(),
-    )
+    const ds = this.ds()
+    const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table))
     const dsOpt = this.getRunQueryOptions(opt)
     const qr = await this.runDatastoreQuery<ROW>(q, dsOpt)
 
@@ -299,12 +275,8 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     dbQuery: DBQuery<ROW>,
     opt: DatastoreDBReadOptions = {},
   ): Promise<number> {
-    const ds = await this.ds()
-    const q = dbQueryToDatastoreQuery(
-      dbQuery,
-      ds.createQuery(dbQuery.table),
-      await this.getPropertyFilter(),
-    )
+    const ds = this.ds()
+    const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table))
     const aq = ds.createAggregationQuery(q).count('count')
     const dsOpt = this.getRunQueryOptions(opt)
     const [entities] = await ds.runAggregationQuery(aq, dsOpt)
@@ -315,7 +287,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     q: Query,
     dsOpt: RunQueryOptions,
   ): Promise<RunQueryResult<ROW>> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const [entities, queryResult] = await ds.runQuery(q, dsOpt)
 
     const rows = entities.map(e => this.mapId<ROW>(e))
@@ -331,13 +303,9 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     _opt?: DatastoreDBStreamOptions,
   ): Pipeline<ROW> {
     return Pipeline.fromAsyncReadable<ROW>(async () => {
-      const ds = await this.ds()
+      const ds = this.ds()
 
-      const q = dbQueryToDatastoreQuery(
-        dbQuery,
-        ds.createQuery(dbQuery.table),
-        await this.getPropertyFilter(),
-      )
+      const q = dbQueryToDatastoreQuery(dbQuery, ds.createQuery(dbQuery.table))
 
       const opt = {
         logger: this.cfg.logger,
@@ -361,7 +329,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     rows: ROW[],
     opt: DatastoreDBSaveOptions<ROW> = {},
   ): Promise<void> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const entities = rows.map(obj =>
       this.toDatastoreEntity(ds, table, obj, opt.excludeFromIndexes as string[]),
     )
@@ -414,12 +382,8 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
       return await this.deleteByIds(q.table, ids, opt)
     }
 
-    const ds = await this.ds()
-    const datastoreQuery = dbQueryToDatastoreQuery(
-      q.select([]),
-      ds.createQuery(q.table),
-      await this.getPropertyFilter(),
-    )
+    const ds = this.ds()
+    const datastoreQuery = dbQueryToDatastoreQuery(q.select([]), ds.createQuery(q.table))
     const dsOpt = this.getRunQueryOptions(opt)
     const { rows } = await this.runDatastoreQuery<ObjectWithId>(datastoreQuery, dsOpt)
     return await this.deleteByIds(
@@ -438,7 +402,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     ids: string[],
     opt: DatastoreDBOptions = {},
   ): Promise<number> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const keys = ids.map(id => this.key(ds, table, id))
 
     const retryOptions = this.getPRetryOptions(`DatastoreLib.deleteByIds(${table})`)
@@ -462,7 +426,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     map: StringMap<string[]>,
     opt: DatastoreDBOptions = {},
   ): Promise<number> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const keys: Key[] = []
     for (const [table, ids] of _stringMapEntries(map)) {
       keys.push(...ids.map(id => this.key(ds, table, id)))
@@ -489,7 +453,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
   override async createTransaction(
     opt: CommonDBTransactionOptions = {},
   ): Promise<DatastoreDBTransaction> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const { readOnly } = opt
     const datastoreTx = ds.transaction({
       readOnly,
@@ -502,7 +466,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     fn: DBTransactionFn,
     opt: CommonDBTransactionOptions = {},
   ): Promise<void> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const { readOnly } = opt
     const datastoreTx = ds.transaction({
       readOnly,
@@ -520,7 +484,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
   }
 
   async getAllStats(): Promise<DatastoreStats[]> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const q = ds.createQuery('__Stat_Kind__')
     const [statsArray] = await ds.runQuery(q)
     return statsArray || []
@@ -530,13 +494,12 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
    * Returns undefined e.g when Table is non-existing
    */
   async getStats(table: string): Promise<DatastoreStats | undefined> {
-    const ds = await this.ds()
-    const propertyFilter = await this.getPropertyFilter()
+    const ds = this.ds()
 
     const q = ds
       .createQuery('__Stat_Kind__')
       // .filter('kind_name', table)
-      .filter(new propertyFilter('kind_name', '=', table))
+      .filter(new PropertyFilter('kind_name', '=', table))
       .limit(1)
     const [statsArray] = await ds.runQuery(q)
     const [stats] = statsArray
@@ -549,11 +512,11 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
   }
 
   async getTableProperties(table: string): Promise<DatastorePropertyStats[]> {
-    const ds = await this.ds()
+    const ds = this.ds()
     const q = ds
       .createQuery('__Stat_PropertyType_PropertyName_Kind__')
       // .filter('kind_name', table)
-      .filter(new (await this.getPropertyFilter())('kind_name', '=', table))
+      .filter(new PropertyFilter('kind_name', '=', table))
     const [stats] = await ds.runQuery(q)
     return stats
   }
@@ -614,7 +577,7 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
 
   override async createTable<ROW extends ObjectWithId>(
     _table: string,
-    _schema: JsonSchemaObject<ROW>,
+    _schema: JsonSchema<ROW>,
   ): Promise<void> {}
 
   override async getTables(): Promise<string[]> {
@@ -623,12 +586,10 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
     return statsArray.map(stats => stats.kind_name).filter(table => table && !table.startsWith('_'))
   }
 
-  override async getTableSchema<ROW extends ObjectWithId>(
-    table: string,
-  ): Promise<JsonSchemaRootObject<ROW>> {
+  override async getTableSchema<ROW extends ObjectWithId>(table: string): Promise<JsonSchema<ROW>> {
     const stats = await this.getTableProperties(table)
 
-    const s: JsonSchemaRootObject<ROW> = {
+    const s: JsonSchema<ROW> = {
       $id: `${table}.schema.json`,
       type: 'object',
       properties: {
@@ -645,40 +606,40 @@ export class DatastoreDB extends BaseCommonDB implements CommonDB {
         const name = stats.property_name as keyof ROW
 
         if (dtype === DatastoreType.Blob) {
-          s.properties[name] = {
+          s.properties![name] = {
             instanceof: 'Buffer',
-          } as JsonSchemaAny
+          } as JsonSchema<any, ROW[typeof name]>
         } else if (dtype === DatastoreType.Text || dtype === DatastoreType.String) {
-          s.properties[name] = {
+          s.properties![name] = {
             type: 'string',
-          } as JsonSchemaString
+          } as JsonSchema<ROW[typeof name]>
         } else if (dtype === DatastoreType.EmbeddedEntity) {
-          s.properties[name] = {
+          s.properties![name] = {
             type: 'object',
             additionalProperties: true,
-            properties: {},
+            properties: {} as any,
             required: [],
-          } as JsonSchemaObject
+          } as JsonSchema<ROW[typeof name]>
         } else if (dtype === DatastoreType.Integer) {
-          s.properties[name] = {
+          s.properties![name] = {
             type: 'integer',
-          } as JsonSchemaNumber
+          } as JsonSchema<ROW[typeof name]>
         } else if (dtype === DatastoreType.Float) {
-          s.properties[name] = {
+          s.properties![name] = {
             type: 'number',
-          } as JsonSchemaNumber
+          } as JsonSchema<ROW[typeof name]>
         } else if (dtype === DatastoreType.Boolean) {
-          s.properties[name] = {
+          s.properties![name] = {
             type: 'boolean',
-          } as JsonSchemaBoolean
+          } as JsonSchema<ROW[typeof name]>
         } else if (dtype === DatastoreType.DATE_TIME) {
           // Don't know how to map it properly
-          s.properties[name] = {} as JsonSchemaAny
+          s.properties![name] = {} as JsonSchema<any>
         } else if (dtype === DatastoreType.NULL) {
           // check, maybe we can just skip this type and do nothing?
-          s.properties[name] ||= {
+          s.properties![name] ||= {
             type: 'null',
-          } as JsonSchemaNull
+          } as JsonSchema<ROW[typeof name]>
         } else {
           throw new Error(
             `Unknown Datastore Type '${stats.property_type}' for ${table}.${name as string}`,

package/src/datastore.model.ts

@@ -128,12 +128,12 @@ export interface DatastoreStats {
 export enum DatastoreType {
   Blob = 'Blob',
   Text = 'Text',
-  String = 'String', // eslint-disable-line id-blacklist
+  String = 'String', // eslint-disable-line id-denylist
   EmbeddedEntity = 'EmbeddedEntity',
   Float = 'Float',
   Integer = 'Integer',
   DATE_TIME = 'Date/Time',
-  Boolean = 'Boolean', // eslint-disable-line id-blacklist
+  Boolean = 'Boolean', // eslint-disable-line id-denylist
   NULL = 'NULL',
 }
 

package/src/query.util.ts

@@ -1,4 +1,4 @@
-import type { PropertyFilter, Query } from '@google-cloud/datastore'
+import { PropertyFilter, type Query } from '@google-cloud/datastore'
 import type { DBQuery, DBQueryFilterOperator } from '@naturalcycles/db-lib'
 import type { ObjectWithId, StringMap } from '@naturalcycles/js-lib/types'
 
@@ -15,7 +15,6 @@ const OP_MAP: Partial<Record<DBQueryFilterOperator, string>> = {
 export function dbQueryToDatastoreQuery<ROW extends ObjectWithId>(
   dbQuery: Readonly<DBQuery<ROW>>,
   emptyQuery: Query,
-  propertyFilterClass: typeof PropertyFilter,
 ): Query {
   let q = emptyQuery
 
@@ -31,7 +30,7 @@ export function dbQueryToDatastoreQuery<ROW extends ObjectWithId>(
     // `a == null` will return just that - rows with null values
     let { op, val } = f
     if (val === undefined) val = null
-    q = q.filter(new propertyFilterClass(f.name as string, OP_MAP[op] || (op as any), val))
+    q = q.filter(new PropertyFilter(f.name as string, OP_MAP[op] || (op as any), val))
   }
 
   // limit