Normalize DB adapter reads/writes

Author: typicode

src/bin.ts

@@ -13,6 +13,8 @@ import type { PackageJson } from "type-fest";
 
 import { fileURLToPath } from "node:url";
 import { createApp } from "./app.ts";
+import { NormalizedAdapter } from "./normalized-adapter.ts";
+import type { RawData } from "./normalized-adapter.ts";
 import { Observer } from "./observer.ts";
 import type { Data } from "./service.ts";
 
@@ -123,16 +125,16 @@ if (readFileSync(file, "utf-8").trim() === "") {
 }
 
 // Set up database
-let adapter: Adapter<Data>;
+let adapter: Adapter<RawData>;
 if (extname(file) === ".json5") {
-  adapter = new DataFile<Data>(file, {
+  adapter = new DataFile<RawData>(file, {
     parse: JSON5.parse,
     stringify: JSON5.stringify,
   });
 } else {
-  adapter = new JSONFile<Data>(file);
+  adapter = new JSONFile<RawData>(file);
 }
-const observer = new Observer(adapter);
+const observer = new Observer(new NormalizedAdapter(adapter));
 
 const db = new Low<Data>(observer, {});
 await db.read();

src/normalized-adapter.test.ts

@@ -0,0 +1,63 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+
+import type { Adapter } from 'lowdb'
+
+import { DEFAULT_SCHEMA_PATH, NormalizedAdapter } from './normalized-adapter.ts'
+import type { RawData } from './normalized-adapter.ts'
+import type { Data } from './service.ts'
+
+class StubAdapter implements Adapter<RawData> {
+  #data: RawData | null
+
+  constructor(data: RawData | null) {
+    this.#data = data
+  }
+
+  async read(): Promise<RawData | null> {
+    return this.#data === null ? null : structuredClone(this.#data)
+  }
+
+  async write(data: RawData): Promise<void> {
+    this.#data = structuredClone(data)
+  }
+
+  get data(): RawData | null {
+    return this.#data
+  }
+}
+
+await test('read removes $schema and normalizes ids', async () => {
+  const adapter = new StubAdapter({
+    $schema: './custom/schema.json',
+    posts: [{ id: 1 }, { title: 'missing id' }],
+    profile: { name: 'x' },
+  })
+
+  const normalized = await new NormalizedAdapter(adapter).read()
+  assert.notEqual(normalized, null)
+
+  if (normalized === null) {
+    return
+  }
+
+  assert.equal(normalized['$schema'], undefined)
+  assert.deepEqual(normalized['profile'], { name: 'x' })
+
+  const posts = normalized['posts']
+  assert.ok(Array.isArray(posts))
+  assert.equal(posts[0]?.['id'], '1')
+  assert.equal(typeof posts[1]?.['id'], 'string')
+  assert.notEqual(posts[1]?.['id'], '')
+})
+
+await test('write always overwrites $schema', async () => {
+  const adapter = new StubAdapter(null)
+  const normalizedAdapter = new NormalizedAdapter(adapter)
+
+  await normalizedAdapter.write({ posts: [{ id: '1' }] } satisfies Data)
+
+  const data = adapter.data
+  assert.notEqual(data, null)
+  assert.equal(data?.['$schema'], DEFAULT_SCHEMA_PATH)
+})

src/normalized-adapter.ts

@@ -0,0 +1,47 @@
+import type { Adapter } from 'lowdb'
+
+import { randomId } from './random-id.ts'
+import type { Data, Item } from './service.ts'
+
+export const DEFAULT_SCHEMA_PATH = './node_modules/json-server/schema.json'
+export type RawData = Record<string, Item[] | Item | string | undefined> & {
+  $schema?: string
+}
+
+export class NormalizedAdapter implements Adapter<Data> {
+  #adapter: Adapter<RawData>
+
+  constructor(adapter: Adapter<RawData>) {
+    this.#adapter = adapter
+  }
+
+  async read(): Promise<Data | null> {
+    const data = await this.#adapter.read()
+
+    if (data === null) {
+      return null
+    }
+
+    delete data['$schema']
+
+    for (const value of Object.values(data)) {
+      if (Array.isArray(value)) {
+        for (const item of value) {
+          if (typeof item['id'] === 'number') {
+            item['id'] = item['id'].toString()
+          }
+
+          if (item['id'] === undefined) {
+            item['id'] = randomId()
+          }
+        }
+      }
+    }
+
+    return data as Data
+  }
+
+  async write(data: Data): Promise<void> {
+    await this.#adapter.write({ ...data, $schema: DEFAULT_SCHEMA_PATH })
+  }
+}

src/random-id.ts

@@ -0,0 +1,5 @@
+import { randomBytes } from 'node:crypto'
+
+export function randomId(): string {
+  return randomBytes(2).toString('hex')
+}

src/service.ts

@@ -1,12 +1,12 @@
-import { randomBytes } from 'node:crypto'
-
 import inflection from 'inflection'
 import { Low } from 'lowdb'
 import sortOn from 'sort-on'
 import type { JsonObject } from 'type-fest'
 
 import { matchesWhere } from './matches-where.ts'
+import { DEFAULT_SCHEMA_PATH } from './normalized-adapter.ts'
 import { paginate, type PaginationResult } from './paginate.ts'
+import { randomId } from './random-id.ts'
 export type Item = Record<string, unknown>
 
 export type Data = Record<string, Item[] | Item>
@@ -15,23 +15,37 @@ export function isItem(obj: unknown): obj is Item {
   return typeof obj === 'object' && obj !== null && !Array.isArray(obj)
 }
 
-export function isData(obj: unknown): obj is Data {
-  if (typeof obj !== 'object' || obj === null) {
-    return false
-  }
-
-  const data = obj as Record<string, unknown>
-  return Object.values(data).every((value) =>
-    Array.isArray(value) ? value.every(isItem) : isItem(value),
-  )
-}
-
 export type PaginatedItems = PaginationResult<Item>
 
 function ensureArray(arg: string | string[] = []): string[] {
   return Array.isArray(arg) ? arg : [arg]
 }
 
+function fixItemsIds(items: Item[]) {
+  items.forEach((item) => {
+    if (typeof item['id'] === 'number') {
+      item['id'] = item['id'].toString()
+    }
+    if (item['id'] === undefined) {
+      item['id'] = randomId()
+    }
+  })
+}
+
+function fixAllItemsIds(data: Data) {
+  Object.values(data).forEach((value) => {
+    if (Array.isArray(value)) {
+      fixItemsIds(value)
+    }
+  })
+}
+
+function fixSchema(data: Data) {
+  if (data['$schema'] === undefined) {
+    ;(data as Record<string, unknown>)['$schema'] = DEFAULT_SCHEMA_PATH
+  }
+}
+
 function embed(db: Low<Data>, name: string, item: Item, related: string): Item {
   if (inflection.singularize(related) === related) {
     const relatedData = db.data[inflection.pluralize(related)] as Item[]
@@ -90,38 +104,6 @@ function deleteDependents(db: Low<Data>, name: string, dependents: string[]) {
   })
 }
 
-function randomId(): string {
-  return randomBytes(2).toString('hex')
-}
-
-function fixItemsIds(items: Item[]) {
-  items.forEach((item) => {
-    if (typeof item['id'] === 'number') {
-      item['id'] = item['id'].toString()
-    }
-    if (item['id'] === undefined) {
-      item['id'] = randomId()
-    }
-  })
-}
-
-// Ensure all items have an id
-function fixAllItemsIds(data: Data) {
-  Object.values(data).forEach((value) => {
-    if (Array.isArray(value)) {
-      fixItemsIds(value)
-    }
-  })
-}
-
-// Ensure $schema is set
-function fixSchema(data: Data) {
-  if (data['$schema'] === undefined) {
-    (data as Record<string, unknown>)['$schema'] =
-      './node_modules/json-server/schema.json'
-  }
-}
-
 export class Service {
   #db: Low<Data>