Better define main CRUD ops' return types

Based on what we discussed this a while back on slack:
https://worldbrain.slack.com/archives/CBLN20LCU/p1545279785004100

I think it's probably better to decide on these return types early on. Not sure exactly about the choices; what do you think?

Author: poltak

ts/backend/index.tests.ts

@@ -35,19 +35,22 @@ export class FakeStorageBackend extends StorageBackend {
 
         const id = this.config.idGenerator(collection, object, options)
         this.createOperations.push({ object, id })
-        return { object: { ...object, [pkIndex]: id } }
+        return {
+            pk: id,
+            object: options.incObject ? { ...object, [pkIndex]: id } : undefined,
+        }
     }
 
     async findObjects() {
         return []
     }
 
     async updateObjects() {
-
+        return { count: 1 }
     }
 
     async deleteObjects() {
-
+        return { count: 1 }
     }
 }
 

ts/index.ts

@@ -22,7 +22,7 @@ import {
 export { default as StorageRegistry } from './registry'
 
 export interface StorageCollection {
-    createObject(object, options? : CreateSingleOptions) : Promise<CreateSingleResult>
+    createObject<PK=string, T=any>(object : T, options? : CreateSingleOptions) : Promise<CreateSingleResult<PK, T>>
     findOneObject<T>(query, options?: FindSingleOptions) : Promise<T | null>
     findObjects<T>(query, options?: FindManyOptions) : Promise<Array<T>>
     countObjects(query, options?: CountOptions) : Promise<number>

ts/types/backend.ts

@@ -2,19 +2,19 @@ import StorageRegistry from "../registry"
 import { StorageBackendFeatureSupport } from "./backend-features";
 import { isRelationshipReference } from "./relationships";
 
-export type CreateSingleOptions = DBNameOptions
-export type CreateSingleResult = {object? : any}
+export type CreateSingleOptions = DBNameOptions & {incObject? : boolean}
+export type CreateSingleResult<PK, T> = {pk : PK, object? : T}
 export type FindSingleOptions = DBNameOptions & IgnoreCaseOptions & ReverseOptions & {fields?: string[]}
 export type FindManyOptions = FindSingleOptions & PaginationOptions
 export type CountOptions = DBNameOptions & IgnoreCaseOptions
-export type UpdateManyOptions = DBNameOptions
-export type UpdateManyResult = any
 export type UpdateSingleOptions = DBNameOptions
-export type UpdateSingleResult = any
+export type UpdateSingleResult = {count? : number}
+export type UpdateManyOptions = DBNameOptions
+export type UpdateManyResult = UpdateSingleResult
 export type DeleteSingleOptions = DBNameOptions
-export type DeleteSingleResult = any
+export type DeleteSingleResult = {count? : number}
 export type DeleteManyOptions = DBNameOptions & {limit? : number}
-export type DeleteManyResult = any
+export type DeleteManyResult = DeleteSingleResult
 
 export type IgnoreCaseOptions = {ignoreCase? : string[]}
 export type ReverseOptions = {reverse? : boolean}
@@ -71,7 +71,11 @@ export abstract class StorageBackend {
     async cleanup() : Promise<any> {}
     async migrate({database} : {database?} = {}) : Promise<any> {}
 
-    abstract async createObject(collection : string, object, options? : CreateSingleOptions)
+    abstract async createObject<PK=string, T=any>(
+        collection : string,
+        object : T,
+        options? : CreateSingleOptions,
+    ) : Promise<CreateSingleResult<PK, T>>
 
     abstract findObjects<T>(collection : string, query, options? : FindManyOptions) : Promise<Array<T>>
     async findObject<T>(collection : string, query, options? : FindSingleOptions) : Promise<T | null> {
@@ -117,7 +121,12 @@ export abstract class StorageBackend {
     async deleteObject(collection : string, object, options? : DeleteSingleOptions) : Promise<DeleteSingleResult> {
         const definition = this.registry.collections[collection]
         if (typeof definition.pkIndex === 'string') {
-            await this.deleteObjects(collection, {[definition.pkIndex]: object[definition.pkIndex]}, {...(options || {}), limit: 1})
+            return this.deleteObjects(collection, {
+                [definition.pkIndex]: object[definition.pkIndex],
+            }, {
+                ...(options || {}),
+                limit: 1,
+            })
         } else {
             throw new Error('Updating single objects with compound pks is not supported yet')
         }
@@ -166,4 +175,4 @@ export function _validateOperationRegistration(identifier, backend : StorageBack
     }
 
     return true
-}
+}