Better version, without any, inspired by Codex

Author: maparent

apps/website/app/api/supabase/content-embedding/route.ts

@@ -41,14 +41,11 @@ const processAndCreateEmbedding = async (
   const { tableName } = tableData;
   // Using getOrCreateEntity, forcing create path by providing non-matching criteria
   // This standardizes return type and error handling (e.g., FK violations from dbUtils)
-  const result =
-    await getOrCreateEntity<"ContentEmbedding_openai_text_embedding_3_small_1536">(
-      {
-        supabase,
-        tableName,
-        insertData: processedItem,
-      },
-    );
+  const result = await getOrCreateEntity({
+    supabase,
+    tableName,
+    insertData: processedItem,
+  });
 
   if (result.error) {
     return result;

apps/website/app/utils/supabase/dbUtils.ts

@@ -4,11 +4,29 @@ import type {
   PostgrestSingleResponse,
 } from "@supabase/supabase-js";
 import { PostgrestError } from "@supabase/supabase-js";
-import type { Database, Tables, TablesInsert } from "@repo/database/dbTypes";
+import type { Database } from "@repo/database/dbTypes";
+
+type PublicTableName = keyof Database["public"]["Tables"];
+type RawTables<TN extends PublicTableName> =
+  Database["public"]["Tables"][TN]["Row"];
+type RawTablesInsert<TN extends PublicTableName> =
+  Database["public"]["Tables"][TN] extends { Insert: unknown }
+    ? Database["public"]["Tables"][TN]["Insert"]
+    : never;
+type RawTablesInsertKey<TN extends PublicTableName> =
+  keyof RawTablesInsert<TN> & string;
+
+// Those next three types would be unions if we ever have more embedding tables
+export type ContentEmbeddingTableName =
+  "ContentEmbedding_openai_text_embedding_3_small_1536";
+export type ContentEmbeddingStrTablesInsert =
+  RawTablesInsert<"ContentEmbedding_openai_text_embedding_3_small_1536">;
+export type ContentEmbeddingStrTables =
+  RawTables<"ContentEmbedding_openai_text_embedding_3_small_1536">;
 
 export const KNOWN_EMBEDDING_TABLES: {
   [key: string]: {
-    tableName: keyof Database["public"]["Tables"];
+    tableName: ContentEmbeddingTableName;
     tableSize: number;
   };
 } = {
@@ -81,20 +99,18 @@ const processSupabaseError = <T>(
  * @param uniqueOn The expected uniqueOn key.
  * @returns Promise<GetOrCreateEntityResult<T>>
  */
-export const getOrCreateEntity = async <
-  TableName extends keyof Database["public"]["Tables"],
->({
+export const getOrCreateEntity = async <TableName extends PublicTableName>({
   supabase,
   tableName,
   insertData,
   uniqueOn = undefined,
 }: {
   supabase: SupabaseClient<Database, "public">;
-  tableName: keyof Database["public"]["Tables"];
-  insertData: TablesInsert<TableName>;
-  uniqueOn?: (keyof TablesInsert<TableName>)[]; // Uses pKey otherwise
-}): Promise<PostgrestSingleResponse<Tables<TableName>>> => {
-  const result: PostgrestSingleResponse<Tables<TableName>> = await supabase
+  tableName: TableName;
+  insertData: RawTablesInsert<TableName>;
+  uniqueOn?: RawTablesInsertKey<TableName>[];
+}): Promise<PostgrestSingleResponse<RawTables<TableName>>> => {
+  const result: PostgrestSingleResponse<RawTables<TableName>> = await supabase
     .from(tableName)
     // Typescript gets confused with latest supabase
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -113,7 +129,7 @@ export const getOrCreateEntity = async <
       if (dup_key_data !== null && dup_key_data.length > 1)
         uniqueOn = dup_key_data[1]!
           .split(",")
-          .map((x) => x.trim()) as (keyof TablesInsert<TableName>)[];
+          .map((x) => x.trim()) as RawTablesInsertKey<TableName>[];
       if (uniqueOn && uniqueOn.length > 0) {
         console.warn(`Attempting to re-fetch using ${uniqueOn.join(", ")}`);
         let reFetchQueryBuilder = supabase.from(tableName).select();
@@ -123,14 +139,21 @@ export const getOrCreateEntity = async <
             console.error("Empty key in uniqueOn");
             continue;
           }
-          const keyS = String(key);
-          reFetchQueryBuilder = reFetchQueryBuilder.eq(
-            keyS,
-            insertData[key] as any, // TS gets confused here?
+          const insertEntry = Object.entries(insertData).find(
+            ([insertKey]) => insertKey === key,
+          );
+          if (!insertEntry) {
+            console.error(`Missing insert data for unique key ${key}`);
+            continue;
+          }
+          reFetchQueryBuilder = reFetchQueryBuilder.filter(
+            key,
+            "eq",
+            insertEntry[1],
           );
         }
         const reFetchResult =
-          await reFetchQueryBuilder.maybeSingle<Tables<TableName>>();
+          await reFetchQueryBuilder.maybeSingle<RawTables<TableName>>();
         const { data: reFetchedEntity, error: reFetchError } = reFetchResult;
 
         if (reFetchResult === null) {
@@ -172,20 +195,18 @@ export type ItemProcessor<TInput, TProcessed> = (item: TInput) => {
 
 export type ItemValidator<T> = (item: T) => string | null;
 
-export const InsertValidatedBatch = async <
-  TableName extends keyof Database["public"]["Tables"],
->({
+export const InsertValidatedBatch = async <TableName extends PublicTableName>({
   supabase,
   tableName,
   items,
   uniqueOn = undefined,
 }: {
   supabase: SupabaseClient<Database, "public">;
-  tableName: keyof Database["public"]["Tables"];
-  items: TablesInsert<TableName>[];
-  uniqueOn?: (keyof TablesInsert<TableName>)[]; // Uses pKey otherwise
-}): Promise<PostgrestResponse<Tables<TableName>>> => {
-  const result: PostgrestResponse<Tables<TableName>> = await supabase
+  tableName: TableName;
+  items: RawTablesInsert<TableName>[];
+  uniqueOn?: RawTablesInsertKey<TableName>[];
+}): Promise<PostgrestResponse<RawTables<TableName>>> => {
+  const result: PostgrestResponse<RawTables<TableName>> = await supabase
     .from(tableName)
     // Typescript gets confused with latest supabase
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
@@ -217,7 +238,7 @@ export const InsertValidatedBatch = async <
 };
 
 export const validateAndInsertBatch = async <
-  TableName extends keyof Database["public"]["Tables"],
+  TableName extends PublicTableName,
 >({
   supabase,
   tableName,
@@ -227,13 +248,13 @@ export const validateAndInsertBatch = async <
   outputValidator = undefined,
 }: {
   supabase: SupabaseClient<Database, "public">;
-  tableName: keyof Database["public"]["Tables"];
-  items: TablesInsert<TableName>[];
-  uniqueOn?: (keyof TablesInsert<TableName>)[]; // Uses pKey otherwise
-  inputValidator?: ItemValidator<TablesInsert<TableName>>;
-  outputValidator?: ItemValidator<Tables<TableName>>;
-}): Promise<PostgrestResponse<Tables<TableName>>> => {
-  let validatedItems: TablesInsert<TableName>[] = [];
+  tableName: TableName;
+  items: RawTablesInsert<TableName>[];
+  uniqueOn?: RawTablesInsertKey<TableName>[];
+  inputValidator?: ItemValidator<RawTablesInsert<TableName>>;
+  outputValidator?: ItemValidator<RawTables<TableName>>;
+}): Promise<PostgrestResponse<RawTables<TableName>>> => {
+  let validatedItems: RawTablesInsert<TableName>[] = [];
   const validationErrors: { index: number; error: string }[] = [];
   if (!Array.isArray(items) || items.length === 0) {
     return {
@@ -301,7 +322,7 @@ export const validateAndInsertBatch = async <
     return result;
   }
   if (outputValidator !== undefined) {
-    const validatedResults: Tables<TableName>[] = [];
+    const validatedResults: RawTables<TableName>[] = [];
     for (let i = 0; i < result.data.length; i++) {
       const item = result.data[i];
       if (!item) {
@@ -355,7 +376,7 @@ export const validateAndInsertBatch = async <
 };
 
 export const processAndInsertBatch = async <
-  TableName extends keyof Database["public"]["Tables"],
+  TableName extends PublicTableName,
   InputType,
   OutputType,
 >({
@@ -367,13 +388,13 @@ export const processAndInsertBatch = async <
   outputProcessor,
 }: {
   supabase: SupabaseClient<Database, "public">;
-  tableName: keyof Database["public"]["Tables"];
+  tableName: TableName;
   items: InputType[];
-  uniqueOn?: (keyof TablesInsert<TableName>)[]; // Uses pKey otherwise
-  inputProcessor: ItemProcessor<InputType, TablesInsert<TableName>>;
-  outputProcessor: ItemProcessor<Tables<TableName>, OutputType>;
+  uniqueOn?: RawTablesInsertKey<TableName>[];
+  inputProcessor: ItemProcessor<InputType, RawTablesInsert<TableName>>;
+  outputProcessor: ItemProcessor<RawTables<TableName>, OutputType>;
 }): Promise<PostgrestResponse<OutputType>> => {
-  const processedItems: TablesInsert<TableName>[] = [];
+  const processedItems: RawTablesInsert<TableName>[] = [];
   const validationErrors: { index: number; error: string }[] = [];
   if (!Array.isArray(items) || items.length === 0) {
     return {