@naturalcycles/db-lib 9.4.1 → 9.5.0

package/src/db.model.ts

@@ -112,7 +112,6 @@ export enum DBRelation {
 export enum DBModelType {
   DBM = 'DBM',
   BM = 'BM',
-  TM = 'TM',
 }
 
 /**

package/src/pipeline/dbPipelineRestore.ts

@@ -10,7 +10,6 @@ import {
   localTime,
   JsonSchemaObject,
   BaseDBEntity,
-  Saved,
 } from '@naturalcycles/js-lib'
 import {
   NDJsonStats,
@@ -217,7 +216,7 @@ export async function dbPipelineRestore(opt: DBPipelineRestoreOptions): Promise<
         }),
         transformLimit({ limit }),
         ...(sinceUpdated
-          ? [transformFilterSync<Saved<BaseDBEntity>>(r => r.updated >= sinceUpdated)]
+          ? [transformFilterSync<BaseDBEntity>(r => r.updated >= sinceUpdated)]
           : []),
         transformMap(mapperPerTable[table] || _passthroughMapper, {
           errorMode,

package/src/query/dbQuery.ts

@@ -1,8 +1,6 @@
 import {
   AsyncMapper,
   _truncate,
-  Saved,
-  AnyObject,
   _objectAssign,
   BaseDBEntity,
   ObjectWithId,
@@ -239,19 +237,18 @@ export class DBQuery<ROW extends ObjectWithId> {
 export class RunnableDBQuery<
   BM extends BaseDBEntity,
   DBM extends BaseDBEntity = BM,
-  TM extends AnyObject = BM,
 > extends DBQuery<DBM> {
   /**
    * Pass `table` to override table.
    */
   constructor(
-    public dao: CommonDao<BM, DBM, TM>,
+    public dao: CommonDao<BM, DBM>,
     table?: string,
   ) {
     super(table || dao.cfg.table)
   }
 
-  async runQuery(opt?: CommonDaoOptions): Promise<Saved<BM>[]> {
+  async runQuery(opt?: CommonDaoOptions): Promise<BM[]> {
     return await this.dao.runQuery(this, opt)
   }
 
@@ -259,26 +256,18 @@ export class RunnableDBQuery<
     return await this.dao.runQuerySingleColumn<T>(this, opt)
   }
 
-  async runQueryAsDBM(opt?: CommonDaoOptions): Promise<Saved<DBM>[]> {
+  async runQueryAsDBM(opt?: CommonDaoOptions): Promise<DBM[]> {
     return await this.dao.runQueryAsDBM(this, opt)
   }
 
-  async runQueryAsTM(opt?: CommonDaoOptions): Promise<TM[]> {
-    return await this.dao.runQueryAsTM(this, opt)
-  }
-
-  async runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<BM>>> {
+  async runQueryExtended(opt?: CommonDaoOptions): Promise<RunQueryResult<BM>> {
     return await this.dao.runQueryExtended(this, opt)
   }
 
-  async runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<Saved<DBM>>> {
+  async runQueryExtendedAsDBM(opt?: CommonDaoOptions): Promise<RunQueryResult<DBM>> {
     return await this.dao.runQueryExtendedAsDBM(this, opt)
   }
 
-  async runQueryExtendedAsTM(opt?: CommonDaoOptions): Promise<RunQueryResult<TM>> {
-    return await this.dao.runQueryExtendedAsTM(this, opt)
-  }
-
   async runQueryCount(opt?: CommonDaoOptions): Promise<number> {
     return await this.dao.runQueryCount(this, opt)
   }
@@ -288,24 +277,24 @@ export class RunnableDBQuery<
   }
 
   async streamQueryForEach(
-    mapper: AsyncMapper<Saved<BM>, void>,
-    opt?: CommonDaoStreamForEachOptions<Saved<BM>>,
+    mapper: AsyncMapper<BM, void>,
+    opt?: CommonDaoStreamForEachOptions<BM>,
   ): Promise<void> {
     await this.dao.streamQueryForEach(this, mapper, opt)
   }
 
   async streamQueryAsDBMForEach(
-    mapper: AsyncMapper<Saved<DBM>, void>,
+    mapper: AsyncMapper<DBM, void>,
     opt?: CommonDaoStreamForEachOptions<DBM>,
   ): Promise<void> {
     await this.dao.streamQueryAsDBMForEach(this, mapper, opt)
   }
 
-  streamQuery(opt?: CommonDaoStreamOptions<Saved<BM>>): ReadableTyped<Saved<BM>> {
+  streamQuery(opt?: CommonDaoStreamOptions<BM>): ReadableTyped<BM> {
     return this.dao.streamQuery(this, opt)
   }
 
-  streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<Saved<DBM>> {
+  streamQueryAsDBM(opt?: CommonDaoStreamOptions<DBM>): ReadableTyped<DBM> {
     return this.dao.streamQueryAsDBM(this, opt)
   }
 

package/src/testing/daoTest.ts

@@ -9,7 +9,6 @@ import {
   createTestItemsBM,
   testItemBMSchema,
   testItemDBMSchema,
-  testItemTMSchema,
   TEST_TABLE,
   createTestItemBM,
   testItemDBMJsonSchema,
@@ -23,7 +22,6 @@ export function runCommonDaoTest(db: CommonDB, quirks: CommonDBImplementationQui
     db,
     dbmSchema: testItemDBMSchema,
     bmSchema: testItemBMSchema,
-    tmSchema: testItemTMSchema,
     logStarted: true,
     logLevel: CommonDaoLogLevel.DATA_FULL,
   })

package/src/testing/test.model.ts

@@ -1,4 +1,4 @@
-import { jsonSchema, _range, BaseDBEntity, Saved, JsonSchemaObject } from '@naturalcycles/js-lib'
+import { jsonSchema, _range, BaseDBEntity, JsonSchemaObject } from '@naturalcycles/js-lib'
 import {
   baseDBEntitySchema,
   binarySchema,
@@ -50,7 +50,10 @@ export const testItemTMSchema = objectSchema<TestItemTM>({
 
 export const testItemBMJsonSchema: JsonSchemaObject<TestItemBM> = jsonSchema
   .rootObject<TestItemBM>({
+    // todo: figure out how to not copy-paste these 3 fields
     id: jsonSchema.string(), // todo: not strictly needed here
+    created: jsonSchema.unixTimestamp(),
+    updated: jsonSchema.unixTimestamp(),
     k1: jsonSchema.string(),
     k2: jsonSchema.oneOf<string | null>([jsonSchema.string(), jsonSchema.null()]).optional(),
     k3: jsonSchema.number().optional(),
@@ -74,7 +77,7 @@ export const testItemDBMJsonSchema: JsonSchemaObject<TestItemDBM> = jsonSchema
   })
   .build()
 
-export function createTestItemDBM(num = 1): Saved<TestItemDBM> {
+export function createTestItemDBM(num = 1): TestItemDBM {
   return {
     id: `id${num}`,
     k1: `v${num}`,
@@ -86,14 +89,14 @@ export function createTestItemDBM(num = 1): Saved<TestItemDBM> {
   }
 }
 
-export function createTestItemBM(num = 1): Saved<TestItemBM> {
+export function createTestItemBM(num = 1): TestItemBM {
   return createTestItemDBM(num)
 }
 
-export function createTestItemsDBM(count = 1): Saved<TestItemDBM>[] {
+export function createTestItemsDBM(count = 1): TestItemDBM[] {
   return _range(1, count + 1).map(num => createTestItemDBM(num))
 }
 
-export function createTestItemsBM(count = 1): Saved<TestItemBM>[] {
+export function createTestItemsBM(count = 1): TestItemBM[] {
   return _range(1, count + 1).map(num => createTestItemBM(num))
 }