@agent-native/core 0.133.2 → 0.133.3

package/corpus/templates/content/actions/add-content-database-source-field-property.ts

@@ -1,4 +1,5 @@
 import { defineAction } from "@agent-native/core";
+import { getDialect } from "@agent-native/core/db";
 import { assertAccess } from "@agent-native/core/sharing";
 import { and, eq, isNull, sql } from "drizzle-orm";
 import { z } from "zod";
@@ -37,6 +38,12 @@ const BUILDER_FIELD_REFRESH_MINIMUM_LIMIT = 500;
 
 type SourceRow = typeof schema.contentDatabaseSourceRows.$inferSelect;
 
+class MissingBuilderFieldValuesError extends Error {
+  constructor(readonly rowCount: number) {
+    super("Builder source field values are missing from the local snapshot.");
+  }
+}
+
 function parseSourceValues(
   value: string | null | undefined,
 ): Record<string, DocumentPropertyValue> {
@@ -61,6 +68,32 @@ function hasSourceFieldValue(
   );
 }
 
+function sourceFieldValueJsonProjection(sourceFieldKey: string) {
+  const sourceValuesJson = schema.contentDatabaseSourceRows.sourceValuesJson;
+  if (getDialect() === "postgres") {
+    return sql<
+      string | null
+    >`(${sourceValuesJson}::jsonb -> ${sourceFieldKey})::text`;
+  }
+
+  const path = `$."${sourceFieldKey}"`;
+  const type = sql<string | null>`json_type(${sourceValuesJson}, ${path})`;
+  return sql<string | null>`CASE
+    WHEN ${type} IS NULL THEN NULL
+    WHEN ${type} = 'true' THEN 'true'
+    WHEN ${type} = 'false' THEN 'false'
+    ELSE json_quote(json_extract(${sourceValuesJson}, ${path}))
+  END`;
+}
+
+function compactSourceValuesJson(
+  sourceFieldKey: string,
+  sourceFieldValueJson: string,
+) {
+  const escapedKey = sourceFieldKey.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+  return `{"${escapedKey}":${sourceFieldValueJson}}`;
+}
+
 function mergeBuilderFieldIntoSourceRows(args: {
   rows: SourceRow[];
   entries: BuilderCmsSourceEntry[];
@@ -383,266 +416,284 @@ export default defineAction({
     }
     const isSecondary = federationRole === "secondary";
 
-    const initialSourceRows = isSecondary
-      ? []
-      : await db
-          .select()
-          .from(schema.contentDatabaseSourceRows)
-          .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
-    const shouldRefreshBuilderField =
-      !isSecondary &&
-      source.sourceType === "builder-cms" &&
-      initialSourceRows.some(
-        (row) => !hasSourceFieldValue(row, field.sourceFieldKey),
-      );
-    let builderEntries: BuilderCmsSourceEntry[] | null = null;
-    if (shouldRefreshBuilderField) {
-      // Read before writing so a Builder outage cannot leave behind a cleanly
-      // reported but empty property. Start at zero even when the source's
-      // broader refresh is incremental: the stored rows we are backfilling
-      // begin with that first page.
-      const builderRead = await readBuilderCmsContentEntries({
-        model: source.sourceTable,
-        fieldPaths: [field.sourceFieldKey],
-        limit: Math.max(
-          BUILDER_FIELD_REFRESH_MINIMUM_LIMIT,
-          initialSourceRows.length,
-        ),
-        offset: 0,
-      });
-      if (builderRead.state !== "live") {
-        throw new Error(
-          builderRead.message ??
-            "Builder CMS could not refresh this field. No property was created.",
-        );
-      }
-      if (initialSourceRows.length > 0 && builderRead.entries.length === 0) {
-        throw new Error(
-          "Builder CMS returned no entries for this source. No property was created; refresh the source and try again.",
-        );
-      }
-      builderEntries = builderRead.entries;
-    }
-
     // Keep the local snapshot, property definition, mapping, and materialized
-    // values atomic. Re-read rows after the provider request so a concurrent
-    // source refresh cannot be overwritten by the older pre-request snapshot.
-    return await db.transaction(async (tx) => {
-      const now = new Date().toISOString();
-      const visibility = normalizePropertyVisibility(undefined);
-      const propertyId = nanoid();
-      const [currentField] = await tx
-        .select()
-        .from(schema.contentDatabaseSourceFields)
-        .where(eq(schema.contentDatabaseSourceFields.id, field.id));
-      if (!currentField) throw new Error("Source field not found.");
-      if (currentField.propertyId) {
-        throw new Error("Source field is already mapped to a property.");
-      }
-      if (currentField.mappingType === "title") {
-        throw new Error("The title source field is already mapped to Name.");
-      }
-      if (currentField.sourceId !== source.id) {
-        throw new Error("Source field does not belong to this database.");
-      }
-      const [currentSource] = await tx
-        .select()
-        .from(schema.contentDatabaseSources)
-        .where(
-          and(
-            eq(schema.contentDatabaseSources.id, source.id),
-            eq(schema.contentDatabaseSources.databaseId, database.id),
-          ),
-        );
-      if (!currentSource) {
-        throw new Error("Source field does not belong to this database.");
-      }
+    // values atomic. The common complete-snapshot path needs one projected row
+    // read. If values are missing, that transaction exits before writes, the
+    // provider read happens outside it, and a second transaction re-reads the
+    // rows so concurrent source refreshes cannot be overwritten.
+    const materializeProperty = (
+      builderEntries: BuilderCmsSourceEntry[] | null,
+    ) =>
+      db.transaction(async (tx) => {
+        const now = new Date().toISOString();
+        const visibility = normalizePropertyVisibility(undefined);
+        const propertyId = nanoid();
+        const [currentField] = await tx
+          .select()
+          .from(schema.contentDatabaseSourceFields)
+          .where(eq(schema.contentDatabaseSourceFields.id, field.id));
+        if (!currentField) throw new Error("Source field not found.");
+        if (currentField.propertyId) {
+          throw new Error("Source field is already mapped to a property.");
+        }
+        if (currentField.mappingType === "title") {
+          throw new Error("The title source field is already mapped to Name.");
+        }
+        if (currentField.sourceId !== source.id) {
+          throw new Error("Source field does not belong to this database.");
+        }
+        const [currentSource] = await tx
+          .select()
+          .from(schema.contentDatabaseSources)
+          .where(
+            and(
+              eq(schema.contentDatabaseSources.id, source.id),
+              eq(schema.contentDatabaseSources.databaseId, database.id),
+            ),
+          );
+        if (!currentSource) {
+          throw new Error("Source field does not belong to this database.");
+        }
 
-      let sourceRows = isSecondary
-        ? []
-        : await tx
+        let sourceRows: Array<{
+          databaseItemId: string;
+          documentId: string;
+          sourceValuesJson: string | null;
+        }> = [];
+        if (builderEntries) {
+          const currentSourceRows = await tx
             .select()
             .from(schema.contentDatabaseSourceRows)
             .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
-      if (builderEntries) {
-        const merged = mergeBuilderFieldIntoSourceRows({
-          rows: sourceRows,
-          entries: builderEntries,
-          sourceTable: source.sourceTable,
-          sourceFieldKey: currentField.sourceFieldKey,
-          now,
-        });
-        if (merged.matchedMissingRows < merged.missingRows) {
-          throw new Error(
-            "Builder CMS did not return entries for every stored source row. No property was created; refresh the source and try again.",
-          );
-        }
-        for (let index = 0; index < merged.rows.length; index += 1) {
-          const currentRow = sourceRows[index];
-          const mergedRow = merged.rows[index];
-          if (
-            !currentRow ||
-            !mergedRow ||
-            currentRow.sourceValuesJson === mergedRow.sourceValuesJson
-          ) {
-            continue;
+          const merged = mergeBuilderFieldIntoSourceRows({
+            rows: currentSourceRows,
+            entries: builderEntries,
+            sourceTable: source.sourceTable,
+            sourceFieldKey: currentField.sourceFieldKey,
+            now,
+          });
+          if (merged.matchedMissingRows < merged.missingRows) {
+            throw new Error(
+              "Builder CMS did not return entries for every stored source row. No property was created; refresh the source and try again.",
+            );
           }
-          const [updatedRow] = await tx
-            .update(schema.contentDatabaseSourceRows)
-            .set({
-              sourceValuesJson: mergedRow.sourceValuesJson,
-              updatedAt: now,
-            })
-            .where(
-              and(
-                eq(schema.contentDatabaseSourceRows.id, currentRow.id),
-                eq(
-                  schema.contentDatabaseSourceRows.sourceValuesJson,
-                  currentRow.sourceValuesJson,
+          for (let index = 0; index < merged.rows.length; index += 1) {
+            const currentRow = currentSourceRows[index];
+            const mergedRow = merged.rows[index];
+            if (
+              !currentRow ||
+              !mergedRow ||
+              currentRow.sourceValuesJson === mergedRow.sourceValuesJson
+            ) {
+              continue;
+            }
+            const [updatedRow] = await tx
+              .update(schema.contentDatabaseSourceRows)
+              .set({
+                sourceValuesJson: mergedRow.sourceValuesJson,
+                updatedAt: now,
+              })
+              .where(
+                and(
+                  eq(schema.contentDatabaseSourceRows.id, currentRow.id),
+                  eq(
+                    schema.contentDatabaseSourceRows.sourceValuesJson,
+                    currentRow.sourceValuesJson,
+                  ),
                 ),
+              )
+              .returning({ id: schema.contentDatabaseSourceRows.id });
+            if (!updatedRow) {
+              throw new Error(
+                "The Builder source changed while adding this property. No property was created; try again.",
+              );
+            }
+          }
+          sourceRows = merged.rows;
+        } else if (!isSecondary) {
+          const projectedSourceRows = await tx
+            .select({
+              databaseItemId: schema.contentDatabaseSourceRows.databaseItemId,
+              documentId: schema.contentDatabaseSourceRows.documentId,
+              sourceFieldValueJson: sourceFieldValueJsonProjection(
+                currentField.sourceFieldKey,
               ),
-            )
-            .returning({ id: schema.contentDatabaseSourceRows.id });
-          if (!updatedRow) {
-            throw new Error(
-              "The Builder source changed while adding this property. No property was created; try again.",
+            })
+            .from(schema.contentDatabaseSourceRows)
+            .where(eq(schema.contentDatabaseSourceRows.sourceId, source.id));
+          if (
+            source.sourceType === "builder-cms" &&
+            projectedSourceRows.some((row) => row.sourceFieldValueJson === null)
+          ) {
+            throw new MissingBuilderFieldValuesError(
+              projectedSourceRows.length,
             );
           }
+          sourceRows = projectedSourceRows.flatMap((row) =>
+            row.sourceFieldValueJson === null
+              ? []
+              : [
+                  {
+                    databaseItemId: row.databaseItemId,
+                    documentId: row.documentId,
+                    sourceValuesJson: compactSourceValuesJson(
+                      currentField.sourceFieldKey,
+                      row.sourceFieldValueJson,
+                    ),
+                  },
+                ],
+          );
         }
-        sourceRows = merged.rows;
-      } else if (
-        source.sourceType === "builder-cms" &&
-        sourceRows.some(
-          (row) => !hasSourceFieldValue(row, currentField.sourceFieldKey),
-        )
-      ) {
-        throw new Error(
-          "The Builder source changed while adding this property. No property was created; try again.",
+
+        const builderMetadata = builderMetadataForSourceField({
+          sourceFieldKey: currentField.sourceFieldKey,
+          sourceMetadataJson: currentSource.metadataJson,
+        });
+        const type = propertyTypeForSourceField(
+          currentField.sourceFieldType,
+          builderMetadata,
         );
-      }
+        const options = sourceFieldPropertyOptions({
+          type,
+          metadata: builderMetadata,
+          rows: sourceRows,
+          sourceFieldKey: currentField.sourceFieldKey,
+        });
+        const [maxPos] = await tx
+          .select({
+            max: sql<number>`COALESCE(MAX(position), -1)`,
+          })
+          .from(schema.documentPropertyDefinitions)
+          .where(
+            and(
+              eq(
+                schema.documentPropertyDefinitions.ownerEmail,
+                database.ownerEmail,
+              ),
+              eq(schema.documentPropertyDefinitions.databaseId, database.id),
+            ),
+          );
+        const position = (maxPos?.max ?? -1) + 1;
+
+        await tx.insert(schema.documentPropertyDefinitions).values({
+          id: propertyId,
+          ownerEmail: database.ownerEmail,
+          orgId: database.orgId ?? null,
+          databaseId: database.id,
+          name: currentField.sourceFieldLabel,
+          type,
+          visibility,
+          optionsJson: serializePropertyOptions(options),
+          position,
+          createdAt: now,
+          updatedAt: now,
+        });
 
-      const builderMetadata = builderMetadataForSourceField({
-        sourceFieldKey: currentField.sourceFieldKey,
-        sourceMetadataJson: currentSource.metadataJson,
-      });
-      const type = propertyTypeForSourceField(
-        currentField.sourceFieldType,
-        builderMetadata,
-      );
-      const options = sourceFieldPropertyOptions({
-        type,
-        metadata: builderMetadata,
-        rows: sourceRows,
-        sourceFieldKey: currentField.sourceFieldKey,
-      });
-      const [maxPos] = await tx
-        .select({
-          max: sql<number>`COALESCE(MAX(position), -1)`,
-        })
-        .from(schema.documentPropertyDefinitions)
-        .where(
-          and(
-            eq(
-              schema.documentPropertyDefinitions.ownerEmail,
-              database.ownerEmail,
+        const [mappedField] = await tx
+          .update(schema.contentDatabaseSourceFields)
+          .set({
+            propertyId,
+            localFieldKey: propertyId,
+            mappingType: "property",
+            updatedAt: now,
+          })
+          .where(
+            and(
+              eq(schema.contentDatabaseSourceFields.id, currentField.id),
+              isNull(schema.contentDatabaseSourceFields.propertyId),
             ),
-            eq(schema.documentPropertyDefinitions.databaseId, database.id),
-          ),
-        );
-      const position = (maxPos?.max ?? -1) + 1;
-
-      await tx.insert(schema.documentPropertyDefinitions).values({
-        id: propertyId,
-        ownerEmail: database.ownerEmail,
-        orgId: database.orgId ?? null,
-        databaseId: database.id,
-        name: currentField.sourceFieldLabel,
-        type,
-        visibility,
-        optionsJson: serializePropertyOptions(options),
-        position,
-        createdAt: now,
-        updatedAt: now,
-      });
+          )
+          .returning({ id: schema.contentDatabaseSourceFields.id });
+        if (!mappedField) {
+          throw new Error("Source field is already mapped to a property.");
+        }
 
-      const [mappedField] = await tx
-        .update(schema.contentDatabaseSourceFields)
-        .set({
-          propertyId,
-          localFieldKey: propertyId,
-          mappingType: "property",
-          updatedAt: now,
-        })
-        .where(
-          and(
-            eq(schema.contentDatabaseSourceFields.id, currentField.id),
-            isNull(schema.contentDatabaseSourceFields.propertyId),
-          ),
-        )
-        .returning({ id: schema.contentDatabaseSourceFields.id });
-      if (!mappedField) {
-        throw new Error("Source field is already mapped to a property.");
-      }
+        await tx
+          .update(schema.contentDatabaseSources)
+          .set({ updatedAt: now })
+          .where(eq(schema.contentDatabaseSources.id, currentSource.id));
 
-      await tx
-        .update(schema.contentDatabaseSources)
-        .set({ updatedAt: now })
-        .where(eq(schema.contentDatabaseSources.id, currentSource.id));
+        const itemValues = sourceFieldPropertyValuesFromRows(
+          sourceRows,
+          currentField.sourceFieldKey,
+          type,
+          options,
+        );
+        if (itemValues.length > 0) {
+          for (const chunk of chunks(itemValues, 200)) {
+            await tx.insert(schema.documentPropertyValues).values(
+              chunk.map((row) => ({
+                id: nanoid(),
+                ownerEmail: database.ownerEmail,
+                documentId: row.documentId,
+                propertyId,
+                valueJson: serializePropertyValue(row.value),
+                createdAt: now,
+                updatedAt: now,
+              })),
+            );
+          }
+        }
 
-      const itemValues = sourceFieldPropertyValuesFromRows(
-        sourceRows,
-        currentField.sourceFieldKey,
-        type,
-        options,
-      );
-      if (itemValues.length > 0) {
-        for (const chunk of chunks(itemValues, 200)) {
-          await tx.insert(schema.documentPropertyValues).values(
-            chunk.map((row) => ({
-              id: nanoid(),
-              ownerEmail: database.ownerEmail,
-              documentId: row.documentId,
-              propertyId,
-              valueJson: serializePropertyValue(row.value),
+        const sourceField = serializeSourceField(
+          {
+            ...currentField,
+            propertyId,
+            localFieldKey: propertyId,
+            mappingType: "property",
+            updatedAt: now,
+          },
+          currentField.sourceFieldLabel,
+        );
+
+        return {
+          databaseId: database.id,
+          documentId: database.documentId,
+          property: {
+            definition: {
+              id: propertyId,
+              databaseId: database.id,
+              name: currentField.sourceFieldLabel,
+              type,
+              visibility,
+              options,
+              position,
               createdAt: now,
               updatedAt: now,
-            })),
-          );
-        }
-      }
+            },
+            value: null,
+            editable: true,
+          },
+          sourceField,
+          itemValues,
+        };
+      });
 
-      const sourceField = serializeSourceField(
-        {
-          ...currentField,
-          propertyId,
-          localFieldKey: propertyId,
-          mappingType: "property",
-          updatedAt: now,
-        },
-        currentField.sourceFieldLabel,
-      );
+    try {
+      return await materializeProperty(null);
+    } catch (error) {
+      if (!(error instanceof MissingBuilderFieldValuesError)) throw error;
 
-      return {
-        databaseId: database.id,
-        documentId: database.documentId,
-        property: {
-          definition: {
-            id: propertyId,
-            databaseId: database.id,
-            name: currentField.sourceFieldLabel,
-            type,
-            visibility,
-            options,
-            position,
-            createdAt: now,
-            updatedAt: now,
-          },
-          value: null,
-          editable: true,
-        },
-        sourceField,
-        itemValues,
-      };
-    });
+      // Read before retrying the transaction so a Builder outage cannot leave
+      // behind a cleanly reported but empty property.
+      const builderRead = await readBuilderCmsContentEntries({
+        model: source.sourceTable,
+        fieldPaths: [field.sourceFieldKey],
+        limit: Math.max(BUILDER_FIELD_REFRESH_MINIMUM_LIMIT, error.rowCount),
+        offset: 0,
+      });
+      if (builderRead.state !== "live") {
+        throw new Error(
+          builderRead.message ??
+            "Builder CMS could not refresh this field. No property was created.",
+        );
+      }
+      if (error.rowCount > 0 && builderRead.entries.length === 0) {
+        throw new Error(
+          "Builder CMS returned no entries for this source. No property was created; refresh the source and try again.",
+        );
+      }
+      return await materializeProperty(builderRead.entries);
+    }
   },
 });

package/corpus/templates/content/actions/add-database-item.ts

@@ -213,8 +213,22 @@ export default defineAction({
       // SQLite writer briefly blocks this best-effort refresh hint.
     });
 
+    const response = await getContentDatabaseResponse(databaseId, {
+      limit: 100,
+      offset: 0,
+    });
+    const createdItem =
+      response.items.find((item) => item.id === itemId) ??
+      (
+        await getContentDatabaseResponse(databaseId, {
+          limit: 1,
+          offset: 0,
+          documentIds: [documentId],
+        })
+      ).items.find((item) => item.id === itemId);
     return {
-      ...(await getContentDatabaseResponse(databaseId)),
+      ...response,
+      createdItem,
       createdItemId: itemId,
       createdDocumentId: documentId,
       createdDocumentUpdatedAt: now,