@agent-native/core 0.114.15 → 0.115.1

package/corpus/templates/crm/actions/save-crm-saved-view.ts

@@ -0,0 +1,119 @@
+import { defineAction } from "@agent-native/core/action";
+import { assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import { getDb, schema } from "../server/db/index.js";
+import { requireCrmScope, toJson } from "./_crm-action-utils.js";
+
+const filterSchema = z.record(z.string().max(120), z.unknown());
+
+export default defineAction({
+  description:
+    "Create or update a bounded, access-scoped CRM saved view. A saved view stores filters and presentation settings, never provider rows.",
+  schema: z.object({
+    id: z.string().min(1).max(128).optional(),
+    name: z.string().trim().min(1).max(120),
+    description: z.string().trim().max(500).optional(),
+    kind: z.enum(["account", "person", "opportunity"]).optional(),
+    filters: filterSchema.optional(),
+    columns: z.array(z.string().trim().min(1).max(120)).max(40).optional(),
+    sort: z
+      .array(
+        z.object({
+          field: z.string().trim().min(1).max(120),
+          direction: z.enum(["asc", "desc"]),
+        }),
+      )
+      .max(4)
+      .optional(),
+    dataProgramId: z.string().trim().min(1).max(128).optional(),
+    pinned: z.boolean().optional(),
+  }),
+  audit: {
+    target: (_args, result) => {
+      const view = result as {
+        id: string;
+        ownerEmail: string;
+        orgId: string | null;
+        visibility: "private" | "org";
+      };
+      return {
+        type: "crm-saved-view",
+        id: view.id,
+        ownerEmail: view.ownerEmail,
+        orgId: view.orgId,
+        visibility: view.visibility,
+      };
+    },
+    summary: (args) => `Saved CRM view ${args.name}`,
+  },
+  run: async (args, ctx) => {
+    const db = getDb();
+    const now = new Date().toISOString();
+    if (args.id) {
+      await assertAccess("crm-saved-view", args.id, "editor");
+      await db
+        .update(schema.crmSavedViews)
+        .set({
+          name: args.name,
+          ...(args.description !== undefined
+            ? { description: args.description }
+            : {}),
+          ...(args.kind !== undefined ? { kind: args.kind } : {}),
+          ...(args.filters !== undefined
+            ? { filtersJson: toJson(args.filters, 8_000) }
+            : {}),
+          ...(args.columns !== undefined
+            ? { columnsJson: toJson(args.columns, 4_000) }
+            : {}),
+          ...(args.sort !== undefined
+            ? { sortJson: toJson(args.sort, 2_000) }
+            : {}),
+          ...(args.dataProgramId !== undefined
+            ? { dataProgramId: args.dataProgramId }
+            : {}),
+          ...(args.pinned !== undefined ? { pinned: args.pinned } : {}),
+          updatedAt: now,
+        })
+        .where(eq(schema.crmSavedViews.id, args.id));
+      const [view] = await db
+        .select()
+        .from(schema.crmSavedViews)
+        .where(eq(schema.crmSavedViews.id, args.id))
+        .limit(1);
+      if (!view) throw new Error("CRM saved view was not found.");
+      return view;
+    }
+
+    const scope = requireCrmScope(ctx);
+    const id = crypto.randomUUID();
+    await db.insert(schema.crmSavedViews).values({
+      id,
+      name: args.name,
+      description: args.description ?? "",
+      kind: args.kind ?? null,
+      filtersJson: toJson(args.filters ?? {}, 8_000),
+      columnsJson: toJson(args.columns ?? [], 4_000),
+      sortJson: toJson(args.sort ?? [], 2_000),
+      dataProgramId: args.dataProgramId ?? null,
+      pinned: args.pinned ?? false,
+      ...scope,
+      createdAt: now,
+      updatedAt: now,
+    });
+    const [view] = await db
+      .select()
+      .from(schema.crmSavedViews)
+      .where(
+        and(
+          eq(schema.crmSavedViews.id, id),
+          eq(schema.crmSavedViews.ownerEmail, scope.ownerEmail),
+        ),
+      )
+      .limit(1);
+    if (!view)
+      throw new Error("CRM saved view could not be verified after saving.");
+    return view;
+  },
+});

package/corpus/templates/crm/actions/sync-crm.ts

@@ -0,0 +1,146 @@
+import { defineAction, type ActionRunContext } from "@agent-native/core/action";
+import { accessFilter, assertAccess } from "@agent-native/core/sharing";
+import { and, eq } from "drizzle-orm";
+import { z } from "zod";
+
+import {
+  createConnectedCrmAdapter,
+  isConnectedCrmProvider,
+} from "../server/crm/adapter.js";
+import {
+  MAX_SYNC_PAGE_SIZE,
+  MAX_SYNC_PAGES,
+  syncCrmMirror,
+} from "../server/crm/crm-mirror.js";
+import { getDb, schema } from "../server/db/index.js";
+import { requireCrmScope } from "./_crm-action-utils.js";
+
+const idList = z
+  .array(z.string().trim().min(1).max(160))
+  .min(1)
+  .max(50)
+  .optional();
+const syncScopeSchema = z
+  .object({
+    pipelineIds: idList,
+    ownerIds: idList,
+    recordIds: idList,
+    associatedRecordIds: idList,
+    updatedAfter: z.string().datetime({ offset: true }).optional(),
+    includeDeleted: z.boolean().default(false),
+  })
+  .superRefine((scope, issue) => {
+    if (
+      !scope.pipelineIds &&
+      !scope.ownerIds &&
+      !scope.recordIds &&
+      !scope.associatedRecordIds &&
+      !scope.updatedAfter
+    ) {
+      issue.addIssue({
+        code: "custom",
+        message:
+          "A sync requires a bounded cohort selector: pipelineIds, ownerIds, recordIds, associatedRecordIds, or updatedAfter.",
+      });
+    }
+  });
+
+export default defineAction({
+  description:
+    "Thinly mirror one bounded HubSpot or Salesforce CRM object cohort. It discovers field policy first, mirrors only explicit safe fields, and returns a continuation cursor instead of claiming an exhaustive sync.",
+  schema: z.object({
+    connectionId: z.string().trim().min(1).max(128),
+    objectType: z.string().trim().min(1).max(120),
+    scope: syncScopeSchema,
+    fieldAllowList: z
+      .array(z.string().trim().min(1).max(120))
+      .min(1)
+      .max(80)
+      .optional(),
+    allowCustomObject: z.boolean().default(false),
+    cursor: z.string().trim().min(1).max(2_000).optional(),
+    pageSize: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(MAX_SYNC_PAGE_SIZE)
+      .default(MAX_SYNC_PAGE_SIZE),
+    maxPages: z.coerce
+      .number()
+      .int()
+      .min(1)
+      .max(MAX_SYNC_PAGES)
+      .default(MAX_SYNC_PAGES),
+  }),
+  audit: {
+    target: (args, result) => {
+      const response = result as {
+        ownerEmail: string;
+        orgId: string | null;
+        visibility: "private" | "org";
+      };
+      return {
+        type: "crm-connection",
+        id: args.connectionId,
+        ownerEmail: response.ownerEmail,
+        orgId: response.orgId,
+        visibility: response.visibility,
+      };
+    },
+    summary: (args) => `Synced bounded CRM ${args.objectType} cohort`,
+    recordInputs: false,
+  },
+  run: async (args, ctx?: ActionRunContext) => {
+    await assertAccess("crm-connection", args.connectionId, "editor");
+    const db = getDb();
+    const [connection] = await db
+      .select()
+      .from(schema.crmConnections)
+      .where(
+        and(
+          eq(schema.crmConnections.id, args.connectionId),
+          accessFilter(
+            schema.crmConnections,
+            schema.crmConnectionShares,
+            undefined,
+            "editor",
+          ),
+        ),
+      )
+      .limit(1);
+    if (!connection || connection.status === "disconnected")
+      throw new Error("CRM connection is unavailable.");
+    if (
+      !isConnectedCrmProvider(connection.provider) ||
+      !connection.workspaceConnectionId
+    )
+      throw new Error(
+        "CRM sync requires a connected HubSpot or Salesforce workspace connection.",
+      );
+    const ownership = requireCrmScope(ctx);
+    const adapter = await createConnectedCrmAdapter({
+      provider: connection.provider,
+      connectionId: connection.workspaceConnectionId,
+      userEmail: ownership.ownerEmail,
+      orgId: ownership.orgId,
+    });
+    const result = await syncCrmMirror({
+      connectionId: connection.id,
+      objectType: args.objectType,
+      scope: { objectType: args.objectType, ...args.scope },
+      fieldAllowList: args.fieldAllowList,
+      allowCustomObject: args.allowCustomObject,
+      cursor: args.cursor,
+      pageSize: args.pageSize,
+      maxPages: args.maxPages,
+      ownership,
+      adapter,
+    });
+    return {
+      ...result,
+      ownerEmail: ownership.ownerEmail,
+      orgId: ownership.orgId,
+      visibility: ownership.visibility,
+    };
+  },
+});