GCP.Integrations reference

AuthConfig

Source: src/GCP/Integrations/AuthConfig.ts

An Application Integration auth config (username/password, token, JWT, service account, …).

Auth configs have no labels field — Alchemy stamps ownership into the description so list / nuke can find them. Location and id are immutable. Display name, description, visibility, and credentials update in place.

AuthConfig: Creating an Auth Config

const auth = yield* GCP.Integrations.AuthConfig("Salesforce", {
  displayName: "salesforce-basic",
  credentialType: "USERNAME_AND_PASSWORD",
  decryptedCredential: {
    credentialType: "USERNAME_AND_PASSWORD",
    usernameAndPassword: { username: "user", password: "secret" },
  },
});

IntegrationsVersion

Source: src/GCP/Integrations/IntegrationsVersion.ts

An Application Integration version (a draft or published snapshot of an integration).

Versions have no labels field — Alchemy stamps ownership into the description. Location, integration id, and version id are immutable. Description, user label, and trigger configs update in place. Draft versions cannot be deleted via the versions API; Alchemy deletes the parent integration instead.

IntegrationsVersion: Creating a Version

const version = yield* GCP.Integrations.IntegrationsVersion("Orders", {
  description: "order workflow",
  triggerConfigs: [
    {
      label: "API Trigger",
      triggerType: "API",
      triggerNumber: "1",
      triggerId: "api_trigger/orders",
      properties: { "Trigger name": "orders" },
    },
  ],
});

IntegrationsVersionsTestCases

Source: src/GCP/Integrations/IntegrationsVersionsTestCases.ts

A functional test case attached to an Application Integration version.

Test cases have no labels field — Alchemy stamps ownership into the description. Parent version and test case id are immutable. Display name, description, and trigger id update in place.

IntegrationsVersionsTestCases: Creating a Test Case

const testCase = yield* GCP.Integrations.IntegrationsVersionsTestCases("HappyPath", {
  version: version.name,
  triggerId: "api_trigger/orders",
  displayName: "happy-path",
  description: "fires the API trigger",
});

ProductsAuthConfig

Source: src/GCP/Integrations/ProductsAuthConfig.ts

A product-scoped Application Integration auth config (projects/.../products/{product}/authConfigs/{authConfig}).

Auth configs have no labels field — Alchemy stamps ownership into the description. Location, product, and id are immutable. Display name, description, visibility, and credentials update in place.

ProductsAuthConfig: Creating a Product Auth Config

const auth = yield* GCP.Integrations.ProductsAuthConfig("Salesforce", {
  product: "IP",
  displayName: "salesforce-basic",
  credentialType: "USERNAME_AND_PASSWORD",
  decryptedCredential: {
    credentialType: "USERNAME_AND_PASSWORD",
    usernameAndPassword: { username: "user", password: "secret" },
  },
});

ProductsCertificate

Source: src/GCP/Integrations/ProductsCertificate.ts

A product-scoped Application Integration client certificate (projects/.../products/{product}/certificates/{certificate}).

Certificates have no labels field — Alchemy stamps ownership into the description. Location, product, and id are immutable. Display name and description update in place. The PEM payload is write-only.

ProductsCertificate: Creating a Certificate

const cert = yield* GCP.Integrations.ProductsCertificate("ClientTls", {
  product: "IP",
  displayName: "client-tls",
  rawCertificate: {
    sslCertificate: pem,
    encryptedPrivateKey: keyPem,
  },
});

ProductsIntegrationsVersion

Source: src/GCP/Integrations/ProductsIntegrationsVersion.ts

A product-scoped Application Integration version (projects/.../products/{product}/integrations/{integration}/versions/{version}).

Versions have no labels field — Alchemy stamps ownership into the description. Location, product, integration id, and version id are immutable. Description, user label, and trigger configs update in place.

ProductsIntegrationsVersion: Creating a Product Version

const version = yield* GCP.Integrations.ProductsIntegrationsVersion("Orders", {
  product: "IP",
  description: "order workflow",
  triggerConfigs: [
    {
      label: "API Trigger",
      triggerType: "API",
      triggerNumber: "1",
      triggerId: "api_trigger/orders",
      properties: { "Trigger name": "orders" },
    },
  ],
});

ProductsSfdcInstance

Source: src/GCP/Integrations/ProductsSfdcInstance.ts

A product-scoped Salesforce instance used by Application Integration (projects/.../products/{product}/sfdcInstances/{sfdcInstance}).

Instances have no labels field — Alchemy stamps ownership into the description. Location, product, and id are immutable. Display name, description, org id, auth configs, and service authority update in place.

ProductsSfdcInstance: Creating a Salesforce Instance

const sfdc = yield* GCP.Integrations.ProductsSfdcInstance("ProdOrg", {
  product: "IP",
  displayName: "prod-org",
  sfdcOrgId: "00D000000000001",
  serviceAuthority: "https://example.my.salesforce.com",
});

ProductsSfdcInstancesSfdcChannel

Source: src/GCP/Integrations/ProductsSfdcInstancesSfdcChannel.ts

A product-scoped Salesforce CDC or Platform Event channel (.../sfdcInstances/{sfdcInstance}/sfdcChannels/{sfdcChannel}).

Channels have no labels field — Alchemy stamps ownership into the description. Parent instance and id are immutable. Display name, description, and topic update in place.

ProductsSfdcInstancesSfdcChannel: Creating a Salesforce Channel

const channel = yield* GCP.Integrations.ProductsSfdcInstancesSfdcChannel("Orders", {
  sfdcInstance: sfdc.name,
  displayName: "orders",
  channelTopic: "/event/AlchemyOrder__e",
});

SfdcInstance

Source: src/GCP/Integrations/SfdcInstance.ts

A Salesforce instance record in Application Integration. Holds org identity and the AuthConfigs used to open SFDC channels.

Instances have no labels field, so Alchemy stamps ownership into the description for list / nuke. Location and id are identity — changing them replaces the instance. Display name, description, org id, auth configs, and service authority update in place.

SfdcInstance: Creating an SFDC Instance

const instance = yield* GCP.Integrations.SfdcInstance("Salesforce", {
  displayName: "prod-org",
  description: "production salesforce",
  sfdcOrgId: "00Dxx0000000001",
});

SfdcInstance: Updating an SFDC Instance

Re-declare the same logical id with changed props; the engine keeps the physical resource and updates it in place.

const instance = yield* GCP.Integrations.SfdcInstance("Salesforce", {
  displayName: "prod-org-v2",
  description: "production salesforce v2",
  sfdcOrgId: "00Dxx0000000002",
});

SfdcInstancesSfdcChannel

Source: src/GCP/Integrations/SfdcInstancesSfdcChannel.ts

A Salesforce CDC or Platform Event channel under an Application Integration SFDC instance.

Channels have no labels field, so Alchemy stamps ownership into the description for list / nuke. Parent instance and id are identity — changing them replaces the channel. Display name, description, and channel topic update in place.

SfdcInstancesSfdcChannel: Creating an SFDC Channel

const channel = yield* GCP.Integrations.SfdcInstancesSfdcChannel("Events", {
  sfdcInstance: instance.name,
  displayName: "account-events",
  channelTopic: "/event/AlchemyTest__e",
});

SfdcInstancesSfdcChannel: Updating an SFDC Channel

Re-declare the same logical id with changed props; the engine keeps the physical resource and updates it in place.

const channel = yield* GCP.Integrations.SfdcInstancesSfdcChannel("Events", {
  sfdcInstance: instance.name,
  displayName: "account-events-v2",
  channelTopic: "/event/AlchemyTest__e",
});

Template

Source: src/GCP/Integrations/Template.ts

An Application Integration template: a reusable integration bundle plus metadata (categories, tags, visibility).

Templates have no labels field, so Alchemy stamps ownership into the description for list / nuke. Location and id are identity — changing them replaces the template. Display name, description, bundle, tags, categories, and visibility update in place.

Template: Creating a Template

const template = yield* GCP.Integrations.Template("Orders", {
  displayName: "order-sync",
  description: "sync orders",
  tags: ["orders"],
  categories: ["SALES_AND_MARKETING"],
});

Template: Updating a Template

Re-declare the same logical id with changed props; the engine keeps the physical resource and updates it in place.

const template = yield* GCP.Integrations.Template("Orders", {
  displayName: "order-sync-v2",
  description: "sync orders v2",
  tags: ["orders", "v2"],
  categories: ["SALES_AND_MARKETING"],
});