build: import assets + authors tables

Author: harjot1singh

package.json

@@ -50,7 +50,6 @@
     "@biomejs/biome": "^1.9.4",
     "@commitlint/cli": "^19.7.1",
     "@commitlint/config-conventional": "^19.7.1",
-    "@libsql/client": "^0.15.1",
     "@types/bun": "^1.2.8",
     "ajv": "^8.17.1",
     "consola": "^3.4.2",

scripts/build-database.ts

@@ -5,8 +5,13 @@ import { basename } from 'node:path'
 import { Glob } from 'bun'
 import { consola } from 'consola'
 import { drizzle } from 'drizzle-orm/bun-sqlite'
+import type { SQLiteTable, TableConfig } from 'drizzle-orm/sqlite-core'
 import { parse } from 'smol-toml'
 import * as schema from '#~/schema'
+
+import type { Asset } from '../collections/$schemas/.types/assets'
+import type { Author } from '../collections/$schemas/.types/authors'
+
 const require = createRequire(import.meta.url)
 
 type DrizzleKitApi = typeof import('drizzle-kit/api')
@@ -41,27 +46,43 @@ for (const stmt of createStatements) {
 
 consola.success('Database initialized\n')
 
-consola.start('Importing assets')
+const scan = (path: string) => new Glob(path).scan()
 
-import type { Asset } from '../collections/$schemas/.types/assets'
+const importCollection = async <CollectionSchema, DatabaseSchema extends SQLiteTable<TableConfig>>(
+  name: string,
+  schema: DatabaseSchema,
+  mapper: (schema: CollectionSchema, id: string) => DatabaseSchema['$inferInsert'],
+) => {
+  consola.start(`Importing ${name}`)
 
-const scan = (path: string) => new Glob(path).scan()
+  const statements = []
 
-const statements = []
+  for await (const filePath of scan(`./collections/${name}/**/*.toml`)) {
+    const id = basename(filePath, '.toml')
+    const data = parse(await readFile(filePath, 'utf-8')) as unknown as CollectionSchema
 
-for await (const filePath of scan('./collections/assets/**/*.toml')) {
-  const id = basename(filePath, '.toml')
-  const data = parse(await readFile(filePath, 'utf-8')) as unknown as Asset
+    statements.push(db.insert(schema).values(mapper(data, id)))
+  }
 
-  statements.push(
-    db.insert(schema.assets).values({
-      id,
-      name: data.name,
-      reference: data.reference,
-    }),
-  )
+  return Promise.all(statements).then(() => consola.success(`Imported ${name}\n`))
 }
 
-await Promise.all(statements)
+await importCollection<Asset, typeof schema.assets>(
+  'assets',
+  schema.assets,
+  ({ name, reference }, id) => ({
+    id,
+    name,
+    reference,
+  }),
+)
 
-consola.success('Imported assets\n')
+await importCollection<Author, typeof schema.authors>(
+  'authors',
+  schema.authors,
+  ({ name, otherNames }, id) => ({
+    id,
+    name,
+    otherNames,
+  }),
+)

src/relations.ts

@@ -43,5 +43,25 @@ export default defineRelations(schema, (r) => ({
       from: r.lines.lineGroupId,
       to: r.lineGroups.id,
     }),
+    assetContent: r.many.assetLines({
+      from: r.lines.id,
+      to: r.assetLines.lineId,
+    }),
+  },
+  assetLines: {
+    line: r.one.lines({
+      from: r.assetLines.lineId,
+      to: r.lines.id,
+    }),
+    asset: r.one.assets({
+      from: r.assetLines.assetId,
+      to: r.assets.id,
+    }),
+  },
+  assets: {
+    lines: r.many.assetLines({
+      from: r.assets.id,
+      to: r.assetLines.assetId,
+    }),
   },
 }))

src/schema.ts

@@ -31,12 +31,20 @@ export const lineGroups = sqliteTable('line_groups', {
   id: text().primaryKey(),
   sectionId: text(),
   authorId: text(),
-  index: integer(),
+  order: integer(),
 })
 
 export const lines = sqliteTable('lines', {
   id: text().primaryKey(),
   lineGroupId: text(),
   content: json(),
-  index: integer(),
+  order: integer(),
+})
+
+export const assetLines = sqliteTable('asset_lines', {
+  assetId: text(),
+  lineId: text(),
+  type: text(),
+  language: text(),
+  data: text(),
 })