🔨 fix various issues

adminSiteServer/apiRouter.ts

@@ -128,6 +128,7 @@ import {
     gdocFromJSON,
     getAllGdocIndexItemsOrderedByUpdatedAt,
     getAndLoadGdocById,
+    getDbEnrichedGdocFromOwidGdoc,
     getGdocBaseObjectById,
     loadGdocFromGdocBase,
     setTagsForGdoc,
@@ -2463,7 +2464,7 @@ postRouteWithRWTransaction(
             gdoc.published = false
             gdoc.createdAt = new Date()
             gdoc.publishedAt = post.published_at
-            await upsertGdoc(trx, gdoc.toDbRawPostGdoc())
+            await upsertGdoc(trx, gdoc)
             await setTagsForGdoc(trx, gdocId, tags)
         }
         return { googleDocsId: gdocId }
@@ -2662,11 +2663,11 @@ putRouteWithRWTransaction(apiRouter, "/gdocs/:id", async (req, res, trx) => {
     // enqueue), so I opted for the version that matches the closest the current
     // baking model, which is "bake what is persisted in the DB". Ultimately, a
     // full sucessful deploy would resolve the state discrepancy either way.
-    await upsertGdoc(trx, nextGdoc.toDbRawPostGdoc())
+    await upsertGdoc(trx, nextGdoc)
 
     const hasChanges = checkHasChanges(prevGdoc, nextGdoc)
-    const prevJson = prevGdoc.toDbRawPostGdoc()
-    const nextJson = nextGdoc.toDbRawPostGdoc()
+    const prevJson = getDbEnrichedGdocFromOwidGdoc(prevGdoc)
+    const nextJson = getDbEnrichedGdocFromOwidGdoc(nextGdoc)
     if (checkIsLightningUpdate(prevJson, nextJson, hasChanges)) {
         await enqueueLightningChange(
             res.locals.user,

adminSiteServer/mockSiteRouter.tsx

@@ -392,13 +392,14 @@ mockSiteRouter.get("/*", async (req, res) => {
 
     await db.knexReadonlyTransaction(async (knex) => {
         try {
-            res.send(await renderGdocsPageBySlug(knex, slug))
+            const page = await renderGdocsPageBySlug(knex, slug)
+            res.send(page)
         } catch (e) {
             console.error(e)
         }
 
         try {
-            const page = renderPageBySlug(slug, knex)
+            const page = await renderPageBySlug(slug, knex)
             res.send(page)
         } catch (e) {
             console.error(e)

db/db.ts

@@ -144,7 +144,19 @@ export const knexRaw = async <TRow = unknown>(
     knex: Knex<any, any[]>,
     str: string,
     params?: any[] | Record<string, any>
-): Promise<TRow[]> => (await knex.raw(str, params ?? []))[0]
+): Promise<TRow[]> => {
+    try {
+        const rawReturnConstruct = await knex.raw(str, params ?? [])
+        return rawReturnConstruct[0]
+    } catch (e) {
+        console.error("Exception when executing SQL statement!", {
+            sql: str,
+            params,
+            error: e,
+        })
+        throw e
+    }
+}
 
 export const knexRawFirst = async <TRow = unknown>(
     knex: Knex<any, any[]>,

db/model/Gdoc/GdocBase.ts

@@ -823,25 +823,14 @@ export class GdocBase implements OwidGdocBaseInterface {
         await this._loadSubclassAttachments(knex)
         await this.validate(knex)
     }
-
-    toDbRawPostGdoc(): DbEnrichedPostGdoc {
-        const readyToSerialize = omit(this, [
-            "_enrichSubclassContent",
-            "_filenameProperties",
-            "_getSubclassEnrichedBlocks",
-            "_omittableFields",
-            "_validateSubclass",
-            ...this._omittableFields,
-        ]) as OwidGdocBaseInterface
-        return readyToSerialize
-    }
 }
 
 // This function would naturally live in GdocFactory but that would create a circular dependency
 export async function getMinimalGdocBaseObjectsByIds(
     knex: KnexReadonlyTransaction,
     ids: string[]
 ): Promise<OwidGdocMinimalPostInterface[]> {
+    if (ids.length === 0) return []
     const rows = await db.knexRaw<{
         id: string
         title: string

db/model/Gdoc/GdocFactory.ts

@@ -1,4 +1,4 @@
-import { get, groupBy } from "lodash"
+import { get, groupBy, omit } from "lodash"
 import { match, P } from "ts-pattern"
 import {
     DATA_INSIGHTS_INDEX_PAGE_SIZE,
@@ -455,15 +455,37 @@ export async function setTagsForGdoc(
         .insert(tagIds.map(({ id: tagId }) => ({ gdocId, tagId })))
 }
 
+export function getDbEnrichedGdocFromOwidGdoc(
+    gdoc: OwidGdoc | GdocBase
+): DbEnrichedPostGdoc {
+    const enrichedGdoc = {
+        breadcrumbs: gdoc.breadcrumbs,
+        content: gdoc.content,
+        createdAt: gdoc.createdAt,
+        id: gdoc.id,
+        markdown: gdoc.markdown,
+        publicationContext: gdoc.publicationContext,
+        published: gdoc.published,
+        publishedAt: gdoc.publishedAt,
+        revisionId: gdoc.revisionId,
+        slug: gdoc.slug,
+        updatedAt: gdoc.updatedAt,
+    } satisfies DbEnrichedPostGdoc
+    return enrichedGdoc
+}
 export async function upsertGdoc(
     knex: KnexReadWriteTransaction,
-    gdoc: DbEnrichedPostGdoc
+    gdoc: OwidGdoc | GdocBase
 ): Promise<number[]> {
-    return knex
+    const enrichedGdoc = getDbEnrichedGdocFromOwidGdoc(gdoc)
+    const rawPost = serializePostsGdocsRow(enrichedGdoc)
+    const query = knex
         .table(PostsGdocsTableName)
-        .insert(serializePostsGdocsRow(gdoc))
+        .insert(rawPost)
         .onConflict("id")
         .merge()
+    console.error(query.toSQL())
+    return query
 }
 
 // TODO:

db/tests/basic.test.ts

@@ -156,14 +156,24 @@ test("knex interface", async () => {
         expect(afterUpdate.length).toBe(2)
         expect(afterUpdate[1].isSuperuser).toBe(1)
 
-        // Use raw queries, using ?? to specify the table name using the shared const value
         // The pick type is used to type the result row
         const usersFromRawQuery: Pick<DbPlainUser, "email">[] = await knexRaw(
             trx,
             "select email from users",
             []
         )
         expect(usersFromRawQuery.length).toBe(2)
+
+        // Check if in queries work as expected
+        const usersFromRawQueryWithInClause: Pick<DbPlainUser, "email">[] =
+            await knexRaw(trx, "select * from users where email in (:emails)", {
+                emails: [
+                    usersFromRawQuery[0].email,
+                    usersFromRawQuery[1].email,
+                ],
+            })
+        expect(usersFromRawQueryWithInClause.length).toBe(2)
+
         await deleteUser(trx, 2)
     }, knexInstance)
 })