feat(bulk): add bulk insert and bulk delete

package.json

@@ -1,6 +1,6 @@
 {
   "name": "functional-models-orm-memory",
-  "version": "3.0.3",
+  "version": "3.0.4",
   "description": "An in-memory datastore adapter for functional-models",
   "main": "index.js",
   "types": "index.d.ts",

src/datastoreAdapter.ts

@@ -28,7 +28,10 @@ type Database = Record<string, Record<PrimaryKeyType, ToObjectResult<any>>>
 const create = ({
   seedData,
   getCollectionNameForModel = defaultCollectionName,
-}: Props = {}): WithRequired<DatastoreAdapter, 'count'> & {
+}: Props = {}): WithRequired<
+  DatastoreAdapter,
+  'count' | 'bulkInsert' | 'bulkDelete'
+> & {
   getRecords: () => Database
 } => {
   const database: Database = clone(seedData) || {}
@@ -43,56 +46,90 @@ const create = ({
     }
     return database[name] as unknown as Record<string, ToObjectResult<TData>>
   }
+  const getRecords = () => {
+    return database
+  }
 
-  return {
-    getRecords: () => {
-      return database
-    },
-    delete: <TData extends DataDescription>(
-      model: OrmModel<TData>,
-      id: PrimaryKeyType
-    ): Promise<void> => {
+  const bulkInsert = async <TData extends DataDescription>(
+    model: OrmModel<TData>,
+    instances: readonly ModelInstance<TData>[]
+  ): Promise<void> => {
+    return Promise.resolve().then(() => {
+      instances.reduce(async (accP, instance) => {
+        const acc = await accP
+        await save(instance)
+        return acc
+      }, Promise.resolve())
+    })
+  }
+  const bulkDelete = async <TData extends DataDescription>(
+    model: OrmModel<TData>,
+    ids: readonly PrimaryKeyType[]
+  ): Promise<void> => {
+    return Promise.resolve().then(() => {
+      ids.reduce(async (accP, id) => {
+        const acc = await accP
+        await deleteObj(model, id)
+        return acc
+      }, Promise.resolve())
+    })
+  }
+
+  const deleteObj = async <TData extends DataDescription>(
+    model: OrmModel<TData>,
+    id: PrimaryKeyType
+  ): Promise<void> => {
+    const records = _getRecords(model)
+    // eslint-disable-next-line functional/immutable-data
+    delete records[id]
+    return Promise.resolve(undefined)
+  }
+
+  const retrieve = async <TData extends DataDescription>(
+    model: OrmModel<TData>,
+    primaryKey: PrimaryKeyType
+  ): Promise<Maybe<ToObjectResult<TData>>> => {
+    return Promise.resolve().then(() => {
       const records = _getRecords(model)
-      // eslint-disable-next-line functional/immutable-data
-      delete records[id]
-      return Promise.resolve(undefined)
-    },
-    retrieve: <TData extends DataDescription>(
-      model: OrmModel<TData>,
-      primaryKey: PrimaryKeyType
-    ): Promise<Maybe<ToObjectResult<TData>>> => {
-      return Promise.resolve().then(() => {
-        const records = _getRecords(model)
-        return records[primaryKey] as unknown as
-          | ToObjectResult<TData>
-          | undefined
-      })
-    },
-    save: async <TData extends DataDescription>(
-      instance: ModelInstance<TData>
-    ): Promise<ToObjectResult<TData>> => {
-      return Promise.resolve().then(async () => {
-        const model = instance.getModel()
-        const data = await instance.toObj<TData>()
-        const records = _getRecords(model)
-        merge(records, { [await instance.getPrimaryKey()]: data })
-        return data
-      })
-    },
-    search: <TData extends DataDescription>(
-      model: OrmModel<TData>,
-      query: OrmSearch
-    ): Promise<DatastoreSearchResult<TData>> => {
+      return records[primaryKey] as unknown as ToObjectResult<TData> | undefined
+    })
+  }
+  const save = async <TData extends DataDescription>(
+    instance: ModelInstance<TData>
+  ): Promise<ToObjectResult<TData>> => {
+    return Promise.resolve().then(async () => {
+      const model = instance.getModel()
+      const data = await instance.toObj<TData>()
+      const records = _getRecords(model)
+      merge(records, { [await instance.getPrimaryKey()]: data })
+      return data
+    })
+  }
+  const search = <TData extends DataDescription>(
+    model: OrmModel<TData>,
+    query: OrmSearch
+  ): Promise<DatastoreSearchResult<TData>> => {
+    const records = _getRecords(model)
+    const instances = filterResults(query, Object.values(records))
+    return Promise.resolve({ instances: instances, page: undefined })
+  }
+
+  const count = <TData extends DataDescription>(model: OrmModel<TData>) => {
+    return Promise.resolve().then(() => {
       const records = _getRecords(model)
-      const instances = filterResults(query, Object.values(records))
-      return Promise.resolve({ instances: instances, page: undefined })
-    },
-    count: <TData extends DataDescription>(model: OrmModel<TData>) => {
-      return Promise.resolve().then(() => {
-        const records = _getRecords(model)
-        return Object.keys(records).length
-      })
-    },
+      return Object.keys(records).length
+    })
+  }
+
+  return {
+    save,
+    delete: deleteObj,
+    retrieve,
+    search,
+    count,
+    bulkInsert,
+    bulkDelete,
+    getRecords,
   }
 }
 

test/src/datastoreAdapter.test.ts

@@ -69,6 +69,22 @@ describe('/src/datastoreAdapter.ts', () => {
         assert.isOk(actual)
       })
     })
+    describe('#bulkInsert()', () => {
+      it('should bulk insert the instances', async () => {
+        const { datastoreAdapter, models } = setup()
+        await datastoreAdapter.bulkInsert(models.Test1Models, [
+          models.Test1Models.create<'id'>({ name: 'my-name' }),
+        ])
+      })
+    })
+    describe('#bulkDelete()', () => {
+      it('should bulk delete the instances', async () => {
+        const { datastoreAdapter, models } = setup()
+        await datastoreAdapter.bulkDelete(models.Test1Models, [
+          '032c282c-b367-4d15-b19a-01c855b38f44',
+        ])
+      })
+    })
     describe('#retrieve()', () => {
       it('should return an object from the seedData when the primary key is provided', async () => {
         const { datastoreAdapter, models } = setup(getSeedData1())