13037350860

Committed 29 Jan 2025 05:52PM UTC coverage: 100.0%. Remained the same

Build # 13037350860

Build Type

Pull #2

github

Committed by

web-flow

Commit Message

Merge 7691c35f3 into 07f1d828a

Pull Request Pull Request #2: feat(all): implement Memory Based Datastore Adapter

Run Details

43 of 43 branches covered (100.0%)

Branch coverage included in aggregate %.

113 of 113 new or added lines in 3 files covered. (100.0%)

115 of 115 relevant lines covered (100.0%)

41.5 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

100.0

/src/datastoreAdapter.ts

import {
  DataDescription,
  DatastoreAdapter,
  DatastoreSearchResult,
  Maybe,
  ModelInstance,
  ModelType,
  OrmModel,
  OrmSearch,
  PrimaryKeyType,
  ToObjectResult,
} from 'functional-models'
import clone from 'lodash/clone'
import merge from 'lodash/merge'
import { filterResults } from './lib'

type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }

type Props = {
  seedData?: Record<string, Record<string | number, any>>
}

const create = ({ seedData }: Props = {}): WithRequired<
  DatastoreAdapter,
  'count'
> => {
  const database: Record<string, Record<string | number, any>> = clone(
    seedData
  ) || {}

  const _getRecords = <TData extends DataDescription>(
    model: ModelType<TData>
  ) => {
    const name = model.getName()
    if (!(name in database)) {
      // eslint-disable-next-line functional/immutable-data
      database[name] = {}
    }
    return database[name] as unknown as Record<string, ToObjectResult<TData>>
  }

  return {
    delete: <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)
    },
    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>> => {
      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
      })
    },
  }
}

export { create }

1	import {
2	DataDescription,
3	DatastoreAdapter,
4	DatastoreSearchResult,
5	Maybe,
6	ModelInstance,
7	ModelType,
8	OrmModel,
9	OrmSearch,
10	PrimaryKeyType,
11	ToObjectResult,
12	} from 'functional-models'
13	import clone from 'lodash/clone'	3✔
14	import merge from 'lodash/merge'	3✔
15	import { filterResults } from './lib'	3✔
16
17	type WithRequired<T, K extends keyof T> = T & { [P in K]-?: T[P] }
18
19	type Props = {
20	seedData?: Record<string, Record<string \| number, any>>
21	}
22
23	const create = ({ seedData }: Props = {}): WithRequired<	3✔
24	DatastoreAdapter,
25	'count'
26	> => {
27	const database: Record<string, Record<string \| number, any>> = clone(	27✔
28	seedData
29	) \|\| {}
30
31	const _getRecords = <TData extends DataDescription>(	27✔
32	model: ModelType<TData>
33	) => {
34	const name = model.getName()	21✔
35	if (!(name in database)) {	21✔
36	// eslint-disable-next-line functional/immutable-data
37	database[name] = {}	6✔
38	}
39	return database[name] as unknown as Record<string, ToObjectResult<TData>>	21✔
40	}
41
42	return {	27✔
43	delete: <TData extends DataDescription>(
44	model: OrmModel<TData>,
45	id: PrimaryKeyType
46	): Promise<void> => {
47	const records = _getRecords(model)	3✔
48	// eslint-disable-next-line functional/immutable-data
49	delete records[id]	3✔
50	return Promise.resolve(undefined)	3✔
51	},
52	retrieve: <TData extends DataDescription>(
53	model: OrmModel<TData>,
54	primaryKey: PrimaryKeyType
55	): Promise<Maybe<ToObjectResult<TData>>> => {
56	return Promise.resolve().then(() => {	6✔
57	const records = _getRecords(model)	6✔
58	return records[primaryKey] as unknown as	6✔
59	\| ToObjectResult<TData>
60	\| undefined
61	})
62	},
63	save: async <TData extends DataDescription>(
64	instance: ModelInstance<TData>
65	): Promise<ToObjectResult<TData>> => {	3✔
66	return Promise.resolve().then(async () => {	3✔
67	const model = instance.getModel()	3✔
68	const data = await instance.toObj<TData>()	3✔
69	const records = _getRecords(model)	3✔
70	merge(records, { [await instance.getPrimaryKey()]: data })	3✔
71	return data	3✔
72	})
73	},
74	search: <TData extends DataDescription>(
75	model: OrmModel<TData>,
76	query: OrmSearch
77	): Promise<DatastoreSearchResult<TData>> => {
78	const records = _getRecords(model)	3✔
79	const instances = filterResults(query, Object.values(records))	3✔
80	return Promise.resolve({ instances: instances, page: undefined })	3✔
81	},
82	count: <TData extends DataDescription>(model: OrmModel<TData>) => {
83	return Promise.resolve().then(() => {	6✔
84	const records = _getRecords(model)	6✔
85	return Object.keys(records).length	6✔
86	})
87	},
88	}
89	}
90
91	export { create }	3✔

monolithst / functional-models-orm-memory / 13037350860

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous