diff --git a/.changeset/feat-http-adapter.md b/.changeset/feat-http-adapter.md new file mode 100644 index 000000000..5b0cf4f76 --- /dev/null +++ b/.changeset/feat-http-adapter.md @@ -0,0 +1,5 @@ +--- +"@tailor-platform/sdk": minor +--- + +Add `defineHttpAdapter()` for declaring HTTP adapters that translate HTTP requests into GraphQL queries and reshape the responses. Adapter files are discovered via the new `httpAdapter.files` glob in `defineConfig()`. At deploy time the `input`/`output` functions are bundled and embedded as gateway filters on the application. Requires the per-workspace feature flag `20260413_platform_filter_router` to be enabled before adapter routes serve traffic. diff --git a/example/adapters/get-user.ts b/example/adapters/get-user.ts new file mode 100644 index 000000000..a4592de92 --- /dev/null +++ b/example/adapters/get-user.ts @@ -0,0 +1,62 @@ +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +function escapeXml(value: unknown): string { + if (value === null || value === undefined) return ""; + const str = + typeof value === "string" || typeof value === "number" || typeof value === "boolean" + ? String(value) + : JSON.stringify(value); + return str + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/"/g, """) + .replace(/'/g, "'"); +} + +export default defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: (req) => { + const segments = req.path.split("/").filter(Boolean); + const id = segments[segments.length - 1] ?? ""; + return { + query: `query GetUser($id: ID!) { + user(id: $id) { + id + name + email + role + status + } + }`, + variables: { id }, + }; + }, + output: (resp) => { + const data = resp.data as { user: Record | null } | null | undefined; + const user = data?.user; + if (!user) { + return { + statusCode: 404, + headers: { "content-type": "application/xml; charset=utf-8" }, + body: `\nuser not found`, + }; + } + const xml = + `\n` + + `` + + `${escapeXml(user.id)}` + + `${escapeXml(user.name)}` + + `${escapeXml(user.email)}` + + `${escapeXml(user.role)}` + + `${escapeXml(user.status)}` + + ``; + return { + statusCode: 200, + headers: { "content-type": "application/xml; charset=utf-8" }, + body: xml, + }; + }, +}); diff --git a/example/adapters/whoami.ts b/example/adapters/whoami.ts new file mode 100644 index 000000000..691e281c6 --- /dev/null +++ b/example/adapters/whoami.ts @@ -0,0 +1,71 @@ +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +function escapeXml(value: unknown): string { + if (value === null || value === undefined) return ""; + const str = + typeof value === "string" || typeof value === "number" || typeof value === "boolean" + ? String(value) + : JSON.stringify(value); + return str + .replace(/&/g, "&") + .replace(//g, ">") + .replace(/"/g, """) + .replace(/'/g, "'"); +} + +function actorXml(tag: string, actor: Record | undefined): string { + if (!actor) return `<${tag} />`; + return ( + `<${tag}>` + + `${escapeXml(actor.id)}` + + `${escapeXml(actor.type)}` + + `${escapeXml(actor.role)}` + + `` + ); +} + +export default defineHttpAdapter({ + name: "whoami", + pathPattern: "/whoami", + methods: ["GET"], + input: () => ({ + query: `query Whoami { + showUserInfo { + user { + id + type + role + } + invoker { + id + type + role + } + } + }`, + }), + output: (resp) => { + const data = resp.data as + | { + showUserInfo?: { + user?: Record; + invoker?: Record; + }; + } + | null + | undefined; + const info = data?.showUserInfo; + const xml = + `\n` + + `` + + actorXml("user", info?.user) + + actorXml("invoker", info?.invoker) + + ``; + return { + statusCode: 200, + headers: { "content-type": "application/xml; charset=utf-8" }, + body: xml, + }; + }, +}); diff --git a/example/tailor.config.ts b/example/tailor.config.ts index 2506ded4d..7e2c774d6 100644 --- a/example/tailor.config.ts +++ b/example/tailor.config.ts @@ -120,6 +120,9 @@ export default defineConfig({ workflow: { files: ["./workflows/**/*.ts"], }, + httpAdapter: { + files: ["./adapters/**/*.ts"], + }, staticWebsites: [website, erdSite], }); diff --git a/packages/sdk/docs/services/http-adapter.md b/packages/sdk/docs/services/http-adapter.md new file mode 100644 index 000000000..d84f115a8 --- /dev/null +++ b/packages/sdk/docs/services/http-adapter.md @@ -0,0 +1,115 @@ +# HTTP Adapter + +HTTP adapters expose REST-style HTTP endpoints on your application's gateway by translating each request into a GraphQL query and (optionally) reshaping the GraphQL response back into an HTTP response. + +## Overview + +Each HTTP adapter is a single file that declares: + +- The HTTP `pathPattern` and `methods` it handles +- An `input` function that converts an incoming HTTP request into a GraphQL request (`query`, `variables`, `operationName`) +- An optional `output` function that converts the GraphQL response into an HTTP response (`statusCode`, `headers`, `body`) + +At deploy time the SDK bundles each `input` and `output` function into a standalone JS script that runs in the gateway's sandboxed runtime when a matching request hits `/f/`. + +## Requirements + +- Each adapter file must call `defineHttpAdapter` exactly once and `export default` the result +- `name` must be a string literal that matches `^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$` and be unique across all adapters +- `input` and `output` must be inline arrow or `function` expressions (not references to functions defined elsewhere) +- `input` and `output` **must be synchronous** — `async`/`await` and top-level `await` are not supported by the gateway runtime + +## Runtime Constraints + +Adapter scripts are bundled to an ES2017 IIFE and executed in the gateway's sandboxed Sobek runtime. The following are **not** available: + +- Node built-in modules (`fs`, `path`, `crypto`, `http`, etc.) — rejected at build time +- `async`/`await` and top-level `await` — rejected at build time +- `fetch`, `setTimeout`, `setInterval`, and other browser/host globals +- Any third-party libraries that depend on the above + +Each bundled script is capped at 256 KB (with a warning at 64 KB). + +## Activation + +HTTP adapters are gated by a per-workspace feature flag (`20260413_platform_filter_router`). Until the flag is enabled for a workspace, requests to `/f/` return `404`. Contact your platform admin to enable adapters in your environment. + +## Configuration + +Add an `httpAdapter` entry to `defineConfig`: + +```typescript +// tailor.config.ts +import { defineConfig } from "@tailor-platform/sdk"; + +export default defineConfig({ + name: "my-app", + httpAdapter: { + files: ["adapters/**/*.ts"], + }, +}); +``` + +## Defining an Adapter + +```typescript +// adapters/get-user.ts +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +export default defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: (req) => ({ + query: `query GetUser($id: ID!) { user(id: $id) { id name email } }`, + variables: { id: req.path.split("/")[2] }, + }), + output: (resp) => ({ + statusCode: 200, + headers: { "content-type": "application/json" }, + body: JSON.stringify(resp.data?.user ?? null), + }), +}); +``` + +A request to `GET /f/users/abc-123` will invoke `input(req)`, execute the resulting GraphQL query against your application's GraphQL endpoint (with the caller's auth context preserved), then invoke `output(resp)` to produce the HTTP response. + +If `output` is omitted, the raw GraphQL response is returned as JSON. + +## Path Pattern + +- Literal segments must match exactly: `/users/list` matches only `/users/list` +- A `*` in the middle matches exactly one segment: `/api/*/users` matches `/api/v1/users` +- A trailing `*` matches all remaining segments: `/api/*` matches `/api/v1/users/123` + +## Type Reference + +```typescript +type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD"; + +type HttpAdapterRequest = { + method: HttpMethod; + path: string; + headers: Record; + query: Record; + body: string; +}; + +type HttpAdapterInputResult = { + query: string; + variables?: Record; + operationName?: string; +}; + +type HttpAdapterGraphQLResponse = { + data?: unknown; + errors?: unknown; + extensions?: unknown; +}; + +type HttpAdapterOutputResult = { + statusCode?: number; + headers?: Record; + body: string; +}; +``` diff --git a/packages/sdk/src/cli/cache/bundle-cache.ts b/packages/sdk/src/cli/cache/bundle-cache.ts index c714e96e5..d9fca02de 100644 --- a/packages/sdk/src/cli/cache/bundle-cache.ts +++ b/packages/sdk/src/cli/cache/bundle-cache.ts @@ -5,7 +5,13 @@ import { hashContent, hashFile, hashFiles } from "./hasher"; import type { CacheStore } from "./store"; import type { Plugin } from "rolldown"; -type BundleKind = "resolver" | "executor" | "workflow-job" | "auth-hook"; +type BundleKind = + | "resolver" + | "executor" + | "workflow-job" + | "auth-hook" + | "http-adapter-input" + | "http-adapter-output"; type BundleCacheRestoreParams = { kind: BundleKind; diff --git a/packages/sdk/src/cli/commands/deploy/application.ts b/packages/sdk/src/cli/commands/deploy/application.ts index 5a26d186b..76ded2ea6 100644 --- a/packages/sdk/src/cli/commands/deploy/application.ts +++ b/packages/sdk/src/cli/commands/deploy/application.ts @@ -11,11 +11,13 @@ import { areNormalizedEqual } from "./compare"; import { buildMetaRequest, hasMatchingSdkVersion, isOwnedByApp } from "./label"; import type { ApplyPhase, PlanContext } from "@/cli/commands/deploy/deploy"; import type { Application } from "@/cli/services/application"; +import type { HttpAdapterBundleResult } from "@/cli/services/http-adapter/bundler"; import type { DeleteApplicationRequestSchema, CreateApplicationRequestSchema, UpdateApplicationRequestSchema, } from "@tailor-proto/tailor/v1/application_pb"; +import type { HttpAdapterSchema } from "@tailor-proto/tailor/v1/http_adapter_resource_pb"; import type { SetMetadataRequestSchema } from "@tailor-proto/tailor/v1/metadata_pb"; /** @@ -82,14 +84,28 @@ type DeleteApplication = { request: MessageInitShape; }; +type ComparableHttpAdapter = { + name: string; + pathPattern: string; + methods: string[]; + inputScript: string; + outputScript: string; + enabled: boolean; + priority: number; +}; + type ComparableApplication = { authNamespace: string; authIdpConfigName: string; cors: string[]; - subgraphs: Array<{ serviceType: Subgraph_ServiceType; serviceNamespace: string }>; + subgraphs: Array<{ + serviceType: Subgraph_ServiceType; + serviceNamespace: string; + }>; allowedIpAddresses: string[]; disableIntrospection: boolean; disabled: boolean; + httpAdapters: ComparableHttpAdapter[]; }; function trn(workspaceId: string, name: string) { @@ -116,6 +132,32 @@ function normalizeSubgraphs( }); } +function normalizeHttpAdapters( + httpAdapters: + | ReadonlyArray<{ + name?: string; + pathPattern?: string; + methods?: string[]; + inputScript?: string; + outputScript?: string; + enabled?: boolean; + priority?: number; + }> + | undefined, +): ComparableHttpAdapter[] { + return [...(httpAdapters ?? [])] + .map((adapter) => ({ + name: adapter.name ?? "", + pathPattern: adapter.pathPattern ?? "", + methods: sortStrings(adapter.methods), + inputScript: adapter.inputScript ?? "", + outputScript: adapter.outputScript ?? "", + enabled: adapter.enabled ?? false, + priority: adapter.priority ?? 0, + })) + .sort((left, right) => left.name.localeCompare(right.name)); +} + function toComparableApplication( input: Pick< ComparableApplication, @@ -126,6 +168,7 @@ function toComparableApplication( | "allowedIpAddresses" | "disableIntrospection" | "disabled" + | "httpAdapters" >, ): ComparableApplication { return { @@ -136,6 +179,7 @@ function toComparableApplication( allowedIpAddresses: sortStrings(input.allowedIpAddresses), disableIntrospection: input.disableIntrospection, disabled: input.disabled, + httpAdapters: [...input.httpAdapters], }; } @@ -144,6 +188,7 @@ function normalizeComparableApplication( authNamespace: string | undefined, authIdpConfigName: string | undefined, cors: string[], + httpAdapters: ReadonlyArray>, ): ComparableApplication { return toComparableApplication({ authNamespace: authNamespace ?? "", @@ -153,6 +198,7 @@ function normalizeComparableApplication( allowedIpAddresses: application.config.allowedIpAddresses ?? [], disableIntrospection: application.config.disableIntrospection ?? false, disabled: false, + httpAdapters: normalizeHttpAdapters(httpAdapters), }); } @@ -165,6 +211,7 @@ function normalizeComparableExistingApplication(app: ProtoApplication): Comparab allowedIpAddresses: app.allowedIpAddresses, disableIntrospection: app.disableIntrospection, disabled: app.disabled, + httpAdapters: normalizeHttpAdapters(app.httpAdapters), }); } @@ -175,9 +222,13 @@ function areApplicationsEqual(existing: ProtoApplication, desired: ComparableApp /** * Plan application changes based on current and desired state. * @param context - Planning context + * @param httpAdapterBuildResult - Bundled HTTP adapter scripts to embed as gateway filters * @returns Planned changes */ -export async function planApplication(context: PlanContext) { +export async function planApplication( + context: PlanContext, + httpAdapterBuildResult?: HttpAdapterBundleResult, +) { const { client, workspaceId, application, forRemoval } = context; const changeSet = createChangeSet( "Applications", @@ -281,11 +332,13 @@ export async function planApplication(context: PlanContext) { "CORS", { expectedLocalNames: expectedLocalWebsites }, ); + const httpAdapters = buildHttpAdapters(application, httpAdapterBuildResult); const desired = normalizeComparableApplication( application, authNamespace, authIdpConfigName, resolvedCors, + httpAdapters, ); const request = { workspaceId, @@ -296,6 +349,7 @@ export async function planApplication(context: PlanContext) { subgraphs: application.subgraphs.map((subgraph) => protoSubgraph(subgraph)), allowedIpAddresses: application.config.allowedIpAddresses, disableIntrospection: application.config.disableIntrospection, + httpAdapters, }; const existing = existingApplications.find((app) => app.name === application.name); @@ -368,6 +422,43 @@ async function fetchAppLabels( } } +function buildHttpAdapters( + application: Readonly, + httpAdapterBuildResult: HttpAdapterBundleResult | undefined, +): MessageInitShape[] { + const adapters = application.httpAdapterService?.adapters ?? []; + if (adapters.length === 0) { + return []; + } + return adapters.map((loaded) => { + const inputScript = httpAdapterBuildResult?.bundledInputs.get(loaded.adapter.name); + if (!inputScript) { + throw new Error( + `HTTP adapter "${loaded.adapter.name}" was loaded but no bundled input script is available`, + ); + } + let outputScript = ""; + if (loaded.hasOutput) { + const bundled = httpAdapterBuildResult?.bundledOutputs.get(loaded.adapter.name); + if (!bundled) { + throw new Error( + `HTTP adapter "${loaded.adapter.name}" declares an output handler but no bundled output script is available`, + ); + } + outputScript = bundled; + } + return { + name: loaded.adapter.name, + pathPattern: loaded.adapter.pathPattern, + methods: loaded.adapter.methods, + inputScript, + outputScript, + enabled: loaded.adapter.enabled ?? true, + priority: loaded.adapter.priority ?? 0, + }; + }); +} + function protoSubgraph( subgraph: Readonly<{ Type: string; Name: string }>, ): MessageInitShape { diff --git a/packages/sdk/src/cli/commands/deploy/deploy.ts b/packages/sdk/src/cli/commands/deploy/deploy.ts index 183f0345d..e433025eb 100644 --- a/packages/sdk/src/cli/commands/deploy/deploy.ts +++ b/packages/sdk/src/cli/commands/deploy/deploy.ts @@ -410,84 +410,97 @@ export async function deploy(options?: DeployOptions) { rootSpan.setAttribute("deploy.dry_run", options?.dryRun ?? false); // Phase 0: Build - const { config, application, workflowBuildResult, bundledScripts, buildOnly } = await withSpan( - "build", - async () => { - const dryRun = options?.dryRun ?? false; - const buildOnly = - options?.buildOnly ?? parseBoolean(process.env.TAILOR_PLATFORM_SDK_BUILD_ONLY) === true; - - const { config, plugins } = await withSpan("build.loadConfig", async () => { - const foundPath = loadConfigPath(options?.configPath); - // Skip id injection in dry-run / build-only flows: those modes are - // expected to have no on-disk side effects. - if (foundPath && !dryRun && !buildOnly) { - const resolvedPath = path.resolve(process.cwd(), foundPath); - if (fs.existsSync(resolvedPath)) { - await ensureConfigId(resolvedPath); - } + const { + config, + application, + workflowBuildResult, + httpAdapterBuildResult, + bundledScripts, + buildOnly, + } = await withSpan("build", async () => { + const dryRun = options?.dryRun ?? false; + const buildOnly = + options?.buildOnly ?? parseBoolean(process.env.TAILOR_PLATFORM_SDK_BUILD_ONLY) === true; + + const { config, plugins } = await withSpan("build.loadConfig", async () => { + const foundPath = loadConfigPath(options?.configPath); + // Skip id injection in dry-run / build-only flows: those modes are + // expected to have no on-disk side effects. + if (foundPath && !dryRun && !buildOnly) { + const resolvedPath = path.resolve(process.cwd(), foundPath); + if (fs.existsSync(resolvedPath)) { + await ensureConfigId(resolvedPath); } - return loadConfig(options?.configPath); - }); + } + return loadConfig(options?.configPath); + }); - const noCache = options?.noCache ?? false; + const noCache = options?.noCache ?? false; - // Initialize cache manager - const packageJson = await readPackageJson(); - const cacheDir = path.resolve(getDistDir(), "cache"); - if (options?.cleanCache) { - fs.rmSync(cacheDir, { recursive: true, force: true }); - logger.info("Bundle cache cleaned"); - } - const configDir = path.dirname(config.path); - const lockfilePath = - findUpSync("pnpm-lock.yaml", { cwd: configDir }) ?? - findUpSync("package-lock.json", { cwd: configDir }) ?? - findUpSync("yarn.lock", { cwd: configDir }) ?? - findUpSync("bun.lock", { cwd: configDir }); - const cacheManager = createCacheManager({ - enabled: !noCache, - cacheDir, - sdkVersion: packageJson.version ?? "unknown", - lockfileHash: lockfilePath ? hashFile(lockfilePath) : undefined, - }); + // Initialize cache manager + const packageJson = await readPackageJson(); + const cacheDir = path.resolve(getDistDir(), "cache"); + if (options?.cleanCache) { + fs.rmSync(cacheDir, { recursive: true, force: true }); + logger.info("Bundle cache cleaned"); + } + const configDir = path.dirname(config.path); + const lockfilePath = + findUpSync("pnpm-lock.yaml", { cwd: configDir }) ?? + findUpSync("package-lock.json", { cwd: configDir }) ?? + findUpSync("yarn.lock", { cwd: configDir }) ?? + findUpSync("bun.lock", { cwd: configDir }); + const cacheManager = createCacheManager({ + enabled: !noCache, + cacheDir, + sdkVersion: packageJson.version ?? "unknown", + lockfileHash: lockfilePath ? hashFile(lockfilePath) : undefined, + }); + + let pluginManager: PluginManager | undefined; + if (plugins.length > 0) { + pluginManager = new PluginManager(plugins); + } - let pluginManager: PluginManager | undefined; - if (plugins.length > 0) { - pluginManager = new PluginManager(plugins); - } + await withSpan("build.generateUserTypes", () => + generateUserTypes({ config, configPath: config.path }), + ); - await withSpan("build.generateUserTypes", () => - generateUserTypes({ config, configPath: config.path }), + let application: Application; + let workflowBuildResult: Awaited>["workflowBuildResult"]; + let httpAdapterBuildResult: Awaited< + ReturnType + >["httpAdapterBuildResult"]; + let bundledScripts: Awaited>["bundledScripts"]; + try { + const result = await withSpan("build.loadApplication", () => + loadApplication({ + config, + pluginManager, + bundleCache: cacheManager.bundleCache, + }), ); + application = result.application; + workflowBuildResult = result.workflowBuildResult; + httpAdapterBuildResult = result.httpAdapterBuildResult; + bundledScripts = result.bundledScripts; + } finally { + // Persist even on partial failure: successfully built bundles + // are cached so the next run only rebuilds what failed. + cacheManager.finalize(); + } - let application: Application; - let workflowBuildResult: Awaited>["workflowBuildResult"]; - let bundledScripts: Awaited>["bundledScripts"]; - try { - const result = await withSpan("build.loadApplication", () => - loadApplication({ config, pluginManager, bundleCache: cacheManager.bundleCache }), - ); - application = result.application; - workflowBuildResult = result.workflowBuildResult; - bundledScripts = result.bundledScripts; - } finally { - // Persist even on partial failure: successfully built bundles - // are cached so the next run only rebuilds what failed. - cacheManager.finalize(); - } - - return { - config, - plugins, - application, - workflowBuildResult, - bundledScripts, - dryRun, - buildOnly, - }; - }, - ); + return { + config, + plugins, + application, + workflowBuildResult, + httpAdapterBuildResult, + bundledScripts, + dryRun, + buildOnly, + }; + }); if (buildOnly) { return { bundledScripts }; } @@ -574,7 +587,7 @@ export async function deploy(options?: DeployOptions) { withSpan("plan.idp", () => planIdP(ctx)), withSpan("plan.auth", () => planAuth(ctx)), withSpan("plan.pipeline", () => planPipeline(ctx)), - withSpan("plan.application", () => planApplication(ctx)), + withSpan("plan.application", () => planApplication(ctx, httpAdapterBuildResult)), withSpan("plan.executor", () => planExecutor(ctx)), withSpan("plan.workflow", () => planWorkflow( diff --git a/packages/sdk/src/cli/services/application.ts b/packages/sdk/src/cli/services/application.ts index c164f3efb..aa5d7444f 100644 --- a/packages/sdk/src/cli/services/application.ts +++ b/packages/sdk/src/cli/services/application.ts @@ -5,6 +5,14 @@ import { bundleAuthHooks } from "@/cli/services/auth/bundler"; import { createAuthService, type AuthService } from "@/cli/services/auth/service"; import { bundleExecutors } from "@/cli/services/executor/bundler"; import { createExecutorService, type ExecutorService } from "@/cli/services/executor/service"; +import { + bundleHttpAdapters, + type HttpAdapterBundleResult, +} from "@/cli/services/http-adapter/bundler"; +import { + createHttpAdapterService, + type HttpAdapterService, +} from "@/cli/services/http-adapter/service"; import { bundleResolvers } from "@/cli/services/resolver/bundler"; import { createResolverService, type ResolverService } from "@/cli/services/resolver/service"; import { createTailorDBService, type TailorDBService } from "@/cli/services/tailordb/service"; @@ -26,6 +34,7 @@ import { type WorkflowServiceConfig, } from "@/types/app-config"; import { type AuthConfig } from "@/types/auth"; +import { type HttpAdapterServiceInput } from "@/types/http-adapter"; import { type IdPConfig } from "@/types/idp"; import { type TailorDBServiceInput } from "@/types/tailordb"; import type { BundleCache } from "@/cli/cache/bundle-cache"; @@ -51,6 +60,7 @@ export type Application = { readonly authService: Readonly | undefined; readonly executorService: Readonly | undefined; readonly workflowService: Readonly | undefined; + readonly httpAdapterService: Readonly | undefined; readonly staticWebsiteServices: ReadonlyArray; readonly secrets: ReadonlyArray; readonly ignoreNullishValues: boolean; @@ -66,6 +76,8 @@ export interface LoadApplicationResult { application: Application; /** Workflow bundling result (if workflows were bundled) */ workflowBuildResult?: BundleWorkflowJobsResult; + /** HTTP adapter bundling result (if adapters were bundled) */ + httpAdapterBuildResult?: HttpAdapterBundleResult; /** In-memory bundled scripts organized by kind */ bundledScripts: BundledScripts; } @@ -199,6 +211,15 @@ function defineWorkflow(config: WorkflowServiceConfig | undefined): WorkflowServ return createWorkflowService({ config }); } +function defineHttpAdapterService( + config: HttpAdapterServiceInput | undefined, +): HttpAdapterService | undefined { + if (!config) { + return undefined; + } + return createHttpAdapterService({ config }); +} + function defineStaticWebsites( websites: readonly StaticWebsiteInput[] | undefined, ): StaticWebsite[] { @@ -290,6 +311,7 @@ function buildApplication(params: { authResult: DefineAuthResult; executorService: ExecutorService | undefined; workflowService: WorkflowService | undefined; + httpAdapterService: HttpAdapterService | undefined; staticWebsiteServices: StaticWebsite[]; secrets: SecretVault[]; ignoreNullishValues: boolean; @@ -312,6 +334,7 @@ function buildApplication(params: { authService: params.authResult.authService, executorService: params.executorService, workflowService: params.workflowService, + httpAdapterService: params.httpAdapterService, staticWebsiteServices: params.staticWebsiteServices, secrets: params.secrets, ignoreNullishValues: params.ignoreNullishValues, @@ -348,12 +371,14 @@ export function defineApplication(params: DefineApplicationParams): Application // Plugin executors are not known at define-time; generate/apply flows handle them after type loading. const executorService = defineExecutor(config.executor, false); const workflowService = defineWorkflow(config.workflow); + const httpAdapterService = defineHttpAdapterService(config.httpAdapter); return buildApplication({ config, ...services, executorService, workflowService, + httpAdapterService, env: config.env ?? {}, }); } @@ -440,6 +465,12 @@ export async function loadApplication( await workflowService.loadWorkflows(); } + // 5.5. Load and collect HTTP adapters + const httpAdapterService = defineHttpAdapterService(config.httpAdapter); + if (httpAdapterService) { + await httpAdapterService.loadAdapters(); + } + // 6. Build trigger context for workflow/job trigger transformation const triggerContext = await buildTriggerContext( config.workflow, @@ -497,6 +528,19 @@ export async function loadApplication( bundledScripts.workflowJobs = workflowBuildResult.bundledCode; } + // 9.25. Bundle HTTP adapters + let httpAdapterBuildResult: HttpAdapterBundleResult | undefined; + if (httpAdapterService && httpAdapterService.adapters.length > 0) { + httpAdapterBuildResult = await bundleHttpAdapters( + httpAdapterService.adapters.map((a) => ({ + name: a.adapter.name, + sourceFile: a.sourceFile, + hasOutput: a.hasOutput, + })), + bundleCache, + ); + } + // 9.5. Bundle auth hooks if (authResult.authService?.config.hooks?.beforeLogin) { const authName = authResult.authService.config.name; @@ -523,6 +567,9 @@ export async function loadApplication( if (workflowService) { workflowService.printLoadedWorkflows(); } + if (httpAdapterService) { + httpAdapterService.printLoadedAdapters(); + } logger.newline(); // 11. Build immutable Application @@ -534,11 +581,12 @@ export async function loadApplication( authResult, executorService, workflowService, + httpAdapterService, staticWebsiteServices, secrets, ignoreNullishValues, env: config.env ?? {}, }); - return { application, workflowBuildResult, bundledScripts }; + return { application, workflowBuildResult, httpAdapterBuildResult, bundledScripts }; } diff --git a/packages/sdk/src/cli/services/http-adapter/bundler.test.ts b/packages/sdk/src/cli/services/http-adapter/bundler.test.ts new file mode 100644 index 000000000..98a8081a5 --- /dev/null +++ b/packages/sdk/src/cli/services/http-adapter/bundler.test.ts @@ -0,0 +1,83 @@ +import * as fs from "node:fs"; +import * as os from "node:os"; +import * as path from "pathe"; +import { afterEach, describe, expect, it } from "vitest"; +import { bundleHttpAdapters } from "./bundler"; + +describe("bundleHttpAdapters", () => { + let tmpDir: string | undefined; + + afterEach(() => { + if (tmpDir) { + fs.rmSync(tmpDir, { recursive: true, force: true }); + tmpDir = undefined; + } + }); + + it("returns empty result when no adapters are provided", async () => { + const result = await bundleHttpAdapters([]); + expect(result.bundledInputs.size).toBe(0); + expect(result.bundledOutputs.size).toBe(0); + }); + + it("bundles input and output scripts that assign globalThis.transform", async () => { + tmpDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "http-adapter-bundle-"))); + const sourceFile = path.join(tmpDir, "adapter.ts"); + fs.writeFileSync( + sourceFile, + ` +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +export default defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: (req) => ({ + query: "query U($id: ID!) { user(id: $id) { id name } }", + variables: { id: req.path.split("/")[2] }, + }), + output: (resp) => ({ + statusCode: 200, + headers: { "content-type": "application/json" }, + body: JSON.stringify(resp.data), + }), +}); +`, + ); + + const result = await bundleHttpAdapters([{ name: "get-user", sourceFile, hasOutput: true }]); + + const inputCode = result.bundledInputs.get("get-user"); + const outputCode = result.bundledOutputs.get("get-user"); + expect(inputCode).toBeDefined(); + expect(outputCode).toBeDefined(); + expect(inputCode).toContain("globalThis.transform"); + expect(outputCode).toContain("globalThis.transform"); + }); + + it("rejects bundles that import Node built-in modules", async () => { + tmpDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "http-adapter-bundle-"))); + const sourceFile = path.join(tmpDir, "adapter.ts"); + fs.writeFileSync( + sourceFile, + ` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +import * as fs from "node:fs"; + +export default defineHttpAdapter({ + name: "bad", + pathPattern: "/bad", + methods: ["GET"], + input: () => { + fs.readFileSync("/etc/passwd"); + return { query: "{}" }; + }, +}); +`, + ); + + await expect( + bundleHttpAdapters([{ name: "bad", sourceFile, hasOutput: false }]), + ).rejects.toThrow(/Node module/); + }); +}); diff --git a/packages/sdk/src/cli/services/http-adapter/bundler.ts b/packages/sdk/src/cli/services/http-adapter/bundler.ts new file mode 100644 index 000000000..3a972d0e9 --- /dev/null +++ b/packages/sdk/src/cli/services/http-adapter/bundler.ts @@ -0,0 +1,213 @@ +import * as fs from "node:fs"; +import * as path from "pathe"; +import { resolveTSConfig } from "pkg-types"; +import * as rolldown from "rolldown"; +import { computeBundlerContextHash, withCache, type BundleCache } from "@/cli/cache/bundle-cache"; +import { getDistDir } from "@/cli/shared/dist-dir"; +import { logger, styles } from "@/cli/shared/logger"; +import ml from "@/utils/multiline"; + +const ADAPTER_BUNDLE_WARN_BYTES = 64 * 1024; +const ADAPTER_BUNDLE_ERROR_BYTES = 256 * 1024; + +const BLOCKED_NODE_MODULES = new Set([ + "fs", + "path", + "os", + "child_process", + "http", + "https", + "net", + "crypto", + "stream", + "url", + "process", + "buffer", + "events", + "util", + "zlib", + "worker_threads", + "perf_hooks", + "dns", + "tls", +]); + +export interface HttpAdapterBundleInput { + name: string; + sourceFile: string; + hasOutput: boolean; +} + +export interface HttpAdapterBundleResult { + /** Adapter name → bundled input JS string. */ + bundledInputs: Map; + /** Adapter name → bundled output JS string. Only populated when the adapter has an output. */ + bundledOutputs: Map; +} + +/** + * Bundle each HTTP adapter's `input` (and `output`, if present) function into a + * single JS string that defines a global `transform(input)` entry point. + * + * The output targets the gateway's Sobek runtime: ES2017 IIFE, no Node imports, + * no async/await, single file (no code splitting). Each function is bundled + * separately so the runtime can run them independently. + * @param adapters - Detected adapters to bundle + * @param cache - Optional bundle cache for skipping unchanged builds + * @returns Bundled scripts keyed by adapter name + */ +export async function bundleHttpAdapters( + adapters: HttpAdapterBundleInput[], + cache?: BundleCache, +): Promise { + if (adapters.length === 0) { + return { bundledInputs: new Map(), bundledOutputs: new Map() }; + } + + logger.newline(); + logger.log( + `Bundling ${styles.highlight(adapters.length.toString())} files for ${styles.info('"http-adapter"')}`, + ); + + const outputDir = path.resolve(getDistDir(), "http-adapters"); + fs.mkdirSync(outputDir, { recursive: true }); + + // Remove stale output files. + const currentNames = new Set(adapters.map((a) => a.name)); + for (const file of fs.readdirSync(outputDir)) { + const base = path.basename(file).replace(/\.(input|output)\.js(\.map)?$/, ""); + if (!currentNames.has(base) && (file.endsWith(".js") || file.endsWith(".js.map"))) { + fs.rmSync(path.join(outputDir, file), { force: true }); + } + } + + let tsconfig: string | undefined; + try { + tsconfig = await resolveTSConfig(); + } catch { + tsconfig = undefined; + } + + const results = await Promise.all( + adapters.flatMap((adapter) => { + const tasks: Array> = [ + bundleAdapterScript(adapter, "input", outputDir, tsconfig, cache), + ]; + if (adapter.hasOutput) { + tasks.push(bundleAdapterScript(adapter, "output", outputDir, tsconfig, cache)); + } + return tasks; + }), + ); + + const bundledInputs = new Map(); + const bundledOutputs = new Map(); + for (const [name, kind, code] of results) { + if (kind === "input") { + bundledInputs.set(name, code); + } else { + bundledOutputs.set(name, code); + } + } + + logger.log(`${styles.success("Bundled")} ${styles.info('"http-adapter"')}`); + + return { bundledInputs, bundledOutputs }; +} + +async function bundleAdapterScript( + adapter: HttpAdapterBundleInput, + kind: "input" | "output", + outputDir: string, + tsconfig: string | undefined, + cache: BundleCache | undefined, +): Promise<[string, "input" | "output", string]> { + const contextHash = computeBundlerContextHash({ + sourceFile: adapter.sourceFile, + serializedTriggerContext: "", + tsconfig, + inlineSourcemap: false, + prefix: kind, + }); + + const code = await withCache({ + cache, + kind: kind === "input" ? "http-adapter-input" : "http-adapter-output", + name: adapter.name, + sourceFile: adapter.sourceFile, + contextHash, + async build(cachePlugins) { + const entryPath = path.join(outputDir, `${adapter.name}.${kind}.entry.js`); + const absoluteSourcePath = path.resolve(adapter.sourceFile); + + const entryContent = ml /* js */ ` + import __adapter from "${absoluteSourcePath}"; + globalThis.transform = __adapter.${kind}; + `; + fs.writeFileSync(entryPath, entryContent); + + const rejectNodeImports: rolldown.Plugin = { + name: "http-adapter-reject-node-imports", + resolveId(source) { + if (source.startsWith("node:")) { + throw new Error( + `HTTP adapter "${adapter.name}" imports Node module "${source}", which is unavailable in the gateway runtime`, + ); + } + if (BLOCKED_NODE_MODULES.has(source)) { + throw new Error( + `HTTP adapter "${adapter.name}" imports Node module "${source}", which is unavailable in the gateway runtime`, + ); + } + return null; + }, + }; + + const plugins: rolldown.Plugin[] = [rejectNodeImports, ...cachePlugins]; + + const result = await rolldown.build({ + input: entryPath, + write: false, + output: { + format: "iife", + sourcemap: false, + minify: true, + codeSplitting: false, + }, + tsconfig, + plugins, + treeshake: { + moduleSideEffects: false, + annotations: true, + unknownGlobalSideEffects: false, + }, + logLevel: "silent", + } as rolldown.BuildOptions); + + const bundled = result.output[0].code; + + // Clean up the temporary entry file. + try { + fs.rmSync(entryPath, { force: true }); + } catch { + // best-effort cleanup + } + + const byteLength = Buffer.byteLength(bundled, "utf8"); + if (byteLength > ADAPTER_BUNDLE_ERROR_BYTES) { + throw new Error( + `HTTP adapter "${adapter.name}" ${kind} script is ${byteLength} bytes, exceeding the ${ADAPTER_BUNDLE_ERROR_BYTES} byte limit`, + ); + } + if (byteLength > ADAPTER_BUNDLE_WARN_BYTES) { + logger.warn( + `HTTP adapter "${adapter.name}" ${kind} script is ${byteLength} bytes, larger than the recommended ${ADAPTER_BUNDLE_WARN_BYTES} byte limit`, + ); + } + + return bundled; + }, + }); + + return [adapter.name, kind, code]; +} diff --git a/packages/sdk/src/cli/services/http-adapter/detector.test.ts b/packages/sdk/src/cli/services/http-adapter/detector.test.ts new file mode 100644 index 000000000..640847fa8 --- /dev/null +++ b/packages/sdk/src/cli/services/http-adapter/detector.test.ts @@ -0,0 +1,135 @@ +import { parseSync } from "oxc-parser"; +import { describe, expect, it } from "vitest"; +import { findHttpAdaptersInFile } from "./detector"; + +function detect(source: string) { + const { program } = parseSync("adapter.ts", source); + return findHttpAdaptersInFile(program, "/virtual/adapter.ts"); +} + +describe("findHttpAdaptersInFile", () => { + it("detects a defineHttpAdapter call and extracts the name", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +export default defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: (req) => ({ query: "{}" }), +}); +`); + expect(result.errors).toEqual([]); + expect(result.adapters).toHaveLength(1); + expect(result.adapters[0].name).toBe("get-user"); + expect(result.adapters[0].hasOutput).toBe(false); + }); + + it("marks adapters that include an output handler", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +export default defineHttpAdapter({ + name: "with-output", + pathPattern: "/x", + methods: ["POST"], + input: () => ({ query: "{}" }), + output: () => ({ body: "" }), +}); +`); + expect(result.errors).toEqual([]); + expect(result.adapters[0].hasOutput).toBe(true); + }); + + it("errors when the name is not a string literal", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +const dynamicName = "x"; +export default defineHttpAdapter({ + name: dynamicName, + pathPattern: "/x", + methods: ["GET"], + input: () => ({ query: "{}" }), +}); +`); + expect(result.adapters).toEqual([]); + expect(result.errors[0].message).toMatch(/static string `name`/); + }); + + it("errors when input is async", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +export default defineHttpAdapter({ + name: "async-input", + pathPattern: "/x", + methods: ["GET"], + input: async () => ({ query: "{}" }), +}); +`); + expect(result.adapters).toEqual([]); + expect(result.errors[0].message).toMatch(/`input` must be synchronous/); + }); + + it("errors when output is async", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +export default defineHttpAdapter({ + name: "async-output", + pathPattern: "/x", + methods: ["GET"], + input: () => ({ query: "{}" }), + output: async () => ({ body: "" }), +}); +`); + expect(result.adapters).toEqual([]); + expect(result.errors[0].message).toMatch(/`output` must be synchronous/); + }); + + it("errors when input is not a function expression", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +const handler = () => ({ query: "{}" }); +export default defineHttpAdapter({ + name: "ref-input", + pathPattern: "/x", + methods: ["GET"], + input: handler, +}); +`); + expect(result.adapters).toEqual([]); + expect(result.errors[0].message).toMatch(/`input` to be a function expression/); + }); + + it("errors when multiple defineHttpAdapter calls exist in one file", () => { + const result = detect(` +import { defineHttpAdapter } from "@tailor-platform/sdk"; + +export const a = defineHttpAdapter({ + name: "one", + pathPattern: "/a", + methods: ["GET"], + input: () => ({ query: "{}" }), +}); + +export default defineHttpAdapter({ + name: "two", + pathPattern: "/b", + methods: ["GET"], + input: () => ({ query: "{}" }), +}); +`); + expect(result.adapters).toEqual([]); + expect(result.errors[0].message).toMatch( + /Expected exactly one defineHttpAdapter call per file/, + ); + }); + + it("ignores files that do not call defineHttpAdapter", () => { + const result = detect(` +import { createWorkflow } from "@tailor-platform/sdk"; +export default createWorkflow({}); +`); + expect(result.adapters).toEqual([]); + expect(result.errors).toEqual([]); + }); +}); diff --git a/packages/sdk/src/cli/services/http-adapter/detector.ts b/packages/sdk/src/cli/services/http-adapter/detector.ts new file mode 100644 index 000000000..0a9377d2b --- /dev/null +++ b/packages/sdk/src/cli/services/http-adapter/detector.ts @@ -0,0 +1,148 @@ +import { + type ASTNode, + isStringLiteral, + isFunctionExpression, + findProperty, +} from "@/cli/services/workflow/ast-utils"; +import { + collectSdkBindings, + isSdkFunctionCall, +} from "@/cli/services/workflow/sdk-binding-collector"; +import type { + Program, + CallExpression, + ObjectExpression, + ArrowFunctionExpression, + Function as FunctionExpression, +} from "@oxc-project/types"; + +export interface HttpAdapterLocation { + name: string; + sourceFile: string; + hasOutput: boolean; +} + +export interface HttpAdapterDetectionError { + sourceFile: string; + message: string; +} + +export interface HttpAdapterDetectionResult { + adapters: HttpAdapterLocation[]; + errors: HttpAdapterDetectionError[]; +} + +/** + * Find the single defineHttpAdapter call in a source file. + * + * By convention, an HTTP adapter file contains exactly one default export of + * `defineHttpAdapter({...})`. Multiple calls within one file produce an error. + * The `name` property must be a string literal so it can be statically resolved. + * `input` (required) and `output` (optional) must be non-async function expressions. + * @param program - Parsed TypeScript program + * @param sourceFile - Absolute path of the source file + * @returns Detection result for the file + */ +export function findHttpAdaptersInFile( + program: Program, + sourceFile: string, +): HttpAdapterDetectionResult { + const adapters: HttpAdapterLocation[] = []; + const errors: HttpAdapterDetectionError[] = []; + const bindings = collectSdkBindings(program, "defineHttpAdapter"); + + function walk(node: ASTNode | null | undefined): void { + if (!node || typeof node !== "object") return; + + if (isSdkFunctionCall(node, bindings, "defineHttpAdapter")) { + const callExpr = node as unknown as CallExpression; + const args = callExpr.arguments; + if (!args || args.length < 1 || args[0]?.type !== "ObjectExpression") { + errors.push({ + sourceFile, + message: "defineHttpAdapter requires an object literal as its sole argument", + }); + return; + } + const configObj = args[0] as ObjectExpression; + const nameProp = findProperty(configObj.properties, "name"); + const inputProp = findProperty(configObj.properties, "input"); + const outputProp = findProperty(configObj.properties, "output"); + + if (!nameProp || !isStringLiteral(nameProp.value)) { + errors.push({ + sourceFile, + message: "defineHttpAdapter requires a static string `name` property", + }); + return; + } + + if (!inputProp || !isFunctionExpression(inputProp.value)) { + errors.push({ + sourceFile, + message: + "defineHttpAdapter requires `input` to be a function expression in the same file", + }); + return; + } + + const inputFn = inputProp.value as ArrowFunctionExpression | FunctionExpression; + if (inputFn.async) { + errors.push({ + sourceFile, + message: + "defineHttpAdapter `input` must be synchronous (the runtime does not support async/await)", + }); + return; + } + + const hasOutput = outputProp !== null; + if (outputProp) { + if (!isFunctionExpression(outputProp.value)) { + errors.push({ + sourceFile, + message: + "defineHttpAdapter `output` must be a function expression in the same file when present", + }); + return; + } + const outputFn = outputProp.value as ArrowFunctionExpression | FunctionExpression; + if (outputFn.async) { + errors.push({ + sourceFile, + message: + "defineHttpAdapter `output` must be synchronous (the runtime does not support async/await)", + }); + return; + } + } + + adapters.push({ + name: nameProp.value.value, + sourceFile, + hasOutput, + }); + } + + for (const key of Object.keys(node)) { + const child = node[key] as unknown; + if (Array.isArray(child)) { + child.forEach((c: unknown) => walk(c as ASTNode | null)); + } else if (child && typeof child === "object") { + walk(child as ASTNode); + } + } + } + + walk(program as unknown as ASTNode); + + if (adapters.length > 1) { + errors.push({ + sourceFile, + message: `Expected exactly one defineHttpAdapter call per file, found ${adapters.length}`, + }); + return { adapters: [], errors }; + } + + return { adapters, errors }; +} diff --git a/packages/sdk/src/cli/services/http-adapter/service.test.ts b/packages/sdk/src/cli/services/http-adapter/service.test.ts new file mode 100644 index 000000000..e2db2e268 --- /dev/null +++ b/packages/sdk/src/cli/services/http-adapter/service.test.ts @@ -0,0 +1,94 @@ +import * as fs from "node:fs"; +import * as os from "node:os"; +import * as path from "pathe"; +import { afterEach, describe, expect, it } from "vitest"; +import { createHttpAdapterService } from "./service"; + +describe("createHttpAdapterService.loadAdapters", () => { + let tmpDir: string | undefined; + + afterEach(() => { + if (tmpDir) { + fs.rmSync(tmpDir, { recursive: true, force: true }); + tmpDir = undefined; + } + }); + + function writeAdapter(name: string, source: string): string { + if (!tmpDir) { + tmpDir = fs.realpathSync(fs.mkdtempSync(path.join(os.tmpdir(), "http-adapter-service-"))); + } + const file = path.join(tmpDir, name); + fs.writeFileSync(file, source); + return file; + } + + it("rejects files containing multiple defineHttpAdapter calls before importing them", async () => { + const file = writeAdapter( + "multi.ts", + ` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +// Importing a Node built-in would normally execute on dynamic import; the +// detector should reject this file before that happens. +import * as fs from "node:fs"; +fs.readFileSync("/etc/passwd"); + +export const a = defineHttpAdapter({ + name: "one", + pathPattern: "/a", + methods: ["GET"], + input: () => ({ query: "{}" }), +}); + +export default defineHttpAdapter({ + name: "two", + pathPattern: "/b", + methods: ["GET"], + input: () => ({ query: "{}" }), +}); +`, + ); + + const service = createHttpAdapterService({ config: { files: [file] } }); + await expect(service.loadAdapters()).rejects.toThrow( + /Expected exactly one defineHttpAdapter call per file/, + ); + }); + + it("rejects files whose name is not a static string literal", async () => { + const file = writeAdapter( + "dynamic-name.ts", + ` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +const dynamicName = "x"; +export default defineHttpAdapter({ + name: dynamicName, + pathPattern: "/x", + methods: ["GET"], + input: () => ({ query: "{}" }), +}); +`, + ); + + const service = createHttpAdapterService({ config: { files: [file] } }); + await expect(service.loadAdapters()).rejects.toThrow(/static string `name`/); + }); + + it("rejects files whose input handler is async", async () => { + const file = writeAdapter( + "async-input.ts", + ` +import { defineHttpAdapter } from "@tailor-platform/sdk"; +export default defineHttpAdapter({ + name: "async-input", + pathPattern: "/x", + methods: ["GET"], + input: async () => ({ query: "{}" }), +}); +`, + ); + + const service = createHttpAdapterService({ config: { files: [file] } }); + await expect(service.loadAdapters()).rejects.toThrow(/`input` must be synchronous/); + }); +}); diff --git a/packages/sdk/src/cli/services/http-adapter/service.ts b/packages/sdk/src/cli/services/http-adapter/service.ts new file mode 100644 index 000000000..b72283477 --- /dev/null +++ b/packages/sdk/src/cli/services/http-adapter/service.ts @@ -0,0 +1,167 @@ +import * as fs from "node:fs/promises"; +import { pathToFileURL } from "node:url"; +import { parseSync } from "oxc-parser"; +import * as path from "pathe"; +import { loadFilesWithIgnores } from "@/cli/services/file-loader"; +import { findHttpAdaptersInFile } from "@/cli/services/http-adapter/detector"; +import { logger, styles } from "@/cli/shared/logger"; +import { HttpAdapterConfigSchema } from "@/parser/service/http-adapter"; +import { isSdkBranded } from "@/utils/brand"; +import type { HttpAdapterConfig, HttpAdapterServiceInput } from "@/types/http-adapter"; + +export type HttpAdapterServiceConfig = HttpAdapterServiceInput; + +export type LoadedHttpAdapter = { + adapter: HttpAdapterConfig; + sourceFile: string; + hasOutput: boolean; +}; + +export type HttpAdapterService = { + readonly config: HttpAdapterServiceConfig; + readonly adapters: ReadonlyArray; + readonly fileCount: number; + loadAdapters: () => Promise; + printLoadedAdapters: () => void; +}; + +export interface CreateHttpAdapterServiceParams { + config: HttpAdapterServiceConfig; +} + +export function createHttpAdapterService( + params: CreateHttpAdapterServiceParams, +): HttpAdapterService { + const { config } = params; + let adapters: LoadedHttpAdapter[] = []; + let fileCount = 0; + let loaded = false; + + return { + config, + get adapters() { + return adapters; + }, + get fileCount() { + return fileCount; + }, + loadAdapters: async () => { + if (loaded) return; + const result = await loadAdapterFiles(config); + adapters = result.adapters; + fileCount = result.fileCount; + loaded = true; + }, + printLoadedAdapters: () => { + if (fileCount === 0) return; + logger.newline(); + logger.log(`Found ${styles.highlight(fileCount.toString())} HTTP adapter files`); + for (const { adapter, sourceFile } of adapters) { + const relativePath = path.relative(process.cwd(), sourceFile); + logger.log( + `HTTP adapter: ${styles.successBright( + `"${adapter.name}"`, + )} loaded from ${styles.path(relativePath)}`, + ); + } + }, + }; +} + +async function loadAdapterFiles( + config: HttpAdapterServiceConfig, +): Promise<{ adapters: LoadedHttpAdapter[]; fileCount: number }> { + if (!config.files || config.files.length === 0) { + return { adapters: [], fileCount: 0 }; + } + + const files = loadFilesWithIgnores(config); + + // Validate AST-level constraints up front so we don't execute (dynamically + // import) any adapter module unless its file structure is valid. + await Promise.all(files.map(validateAdapterFile)); + + const loadResults = await Promise.all(files.map(loadAdapterFromFile)); + + const adapters: LoadedHttpAdapter[] = []; + const seenNames = new Map(); + for (const result of loadResults) { + if (!result) continue; + const existing = seenNames.get(result.adapter.name); + if (existing) { + throw new Error( + `Duplicate HTTP adapter name "${result.adapter.name}" found:\n` + + ` - ${existing}\n` + + ` - ${result.sourceFile}\n` + + `Each HTTP adapter must have a unique name.`, + ); + } + seenNames.set(result.adapter.name, result.sourceFile); + adapters.push(result); + } + + return { adapters, fileCount: files.length }; +} + +async function validateAdapterFile(filePath: string): Promise { + const source = await fs.readFile(filePath, "utf8"); + const { program } = parseSync(filePath, source); + const { errors } = findHttpAdaptersInFile(program, filePath); + if (errors.length === 0) return; + const relativePath = path.relative(process.cwd(), filePath); + const messages = errors.map((e) => ` - ${e.message}`).join("\n"); + throw new Error(`Invalid HTTP adapter file ${relativePath}:\n${messages}`); +} + +async function loadAdapterFromFile(filePath: string): Promise { + try { + const module = await import(pathToFileURL(filePath).href); + const defaultExport = (module as { default?: unknown }).default; + if (defaultExport === undefined) { + return null; + } + + const parsed = HttpAdapterConfigSchema.safeParse(defaultExport); + if (!parsed.success) { + if (isSdkBranded(defaultExport, "http-adapter")) { + throw parsed.error; + } + return null; + } + + const adapter = parsed.data as unknown as HttpAdapterConfig; + rejectAsyncHandlers(adapter, filePath); + + return { + adapter, + sourceFile: filePath, + hasOutput: adapter.output !== undefined, + }; + } catch (error) { + const relativePath = path.relative(process.cwd(), filePath); + logger.error( + `${styles.error("Failed to load HTTP adapter from")} ${styles.errorBright(relativePath)}`, + ); + logger.error(String(error)); + throw error; + } +} + +function rejectAsyncHandlers(adapter: HttpAdapterConfig, sourceFile: string): void { + if (isAsyncFunction(adapter.input)) { + throw new Error( + `HTTP adapter "${adapter.name}" in ${sourceFile} has an async \`input\` function. ` + + `The gateway runtime does not support async/await.`, + ); + } + if (adapter.output !== undefined && isAsyncFunction(adapter.output)) { + throw new Error( + `HTTP adapter "${adapter.name}" in ${sourceFile} has an async \`output\` function. ` + + `The gateway runtime does not support async/await.`, + ); + } +} + +function isAsyncFunction(fn: unknown): boolean { + return typeof fn === "function" && fn.constructor?.name === "AsyncFunction"; +} diff --git a/packages/sdk/src/configure/services/http-adapter/http-adapter.test.ts b/packages/sdk/src/configure/services/http-adapter/http-adapter.test.ts new file mode 100644 index 000000000..038759e41 --- /dev/null +++ b/packages/sdk/src/configure/services/http-adapter/http-adapter.test.ts @@ -0,0 +1,43 @@ +import { describe, expect, it } from "vitest"; +import { SDK_BRAND, isSdkBranded } from "@/utils/brand"; +import { defineHttpAdapter } from "./http-adapter"; + +describe("defineHttpAdapter", () => { + it("returns a branded HTTP adapter object", () => { + const adapter = defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: () => ({ query: "{ me { id } }" }), + }); + + expect(adapter.name).toBe("get-user"); + expect(adapter.pathPattern).toBe("/users/*"); + expect(adapter.methods).toEqual(["GET"]); + expect(typeof adapter.input).toBe("function"); + expect(isSdkBranded(adapter, "http-adapter")).toBe(true); + }); + + it("hides the brand symbol from enumeration", () => { + const adapter = defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: () => ({ query: "{ me { id } }" }), + }); + expect(Object.keys(adapter)).not.toContain(SDK_BRAND.toString()); + expect(Object.getOwnPropertyDescriptor(adapter, SDK_BRAND)?.enumerable).toBe(false); + }); + + it("preserves the output function when provided", () => { + const output = () => ({ body: "" }); + const adapter = defineHttpAdapter({ + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: () => ({ query: "{}" }), + output, + }); + expect(adapter.output).toBe(output); + }); +}); diff --git a/packages/sdk/src/configure/services/http-adapter/http-adapter.ts b/packages/sdk/src/configure/services/http-adapter/http-adapter.ts new file mode 100644 index 000000000..83dd1bd33 --- /dev/null +++ b/packages/sdk/src/configure/services/http-adapter/http-adapter.ts @@ -0,0 +1,45 @@ +import { brandValue } from "@/utils/brand"; +import type { HttpAdapter } from "@/types/http-adapter"; + +export type { + HttpAdapter, + HttpAdapterRequest, + HttpAdapterInputResult, + HttpAdapterInputFn, + HttpAdapterGraphQLResponse, + HttpAdapterOutputResult, + HttpAdapterOutputFn, + HttpMethod, +} from "@/types/http-adapter"; + +/** + * Defines an HTTP adapter that translates HTTP requests to GraphQL queries + * and shapes the GraphQL response back into an HTTP response. + * + * The adapter MUST be the default export of its file. + * Files are discovered via the `httpAdapter.files` glob in `defineConfig()`. + * + * The `input` and `output` functions are bundled into JS strings and executed + * server-side in a sandboxed Sobek (ES2017 subset) runtime. Node APIs, `fetch`, + * `async`/`await`, and top-level `await` are not available at runtime. + * @param config - HTTP adapter configuration + * @returns Branded HTTP adapter definition + * @example + * export default defineHttpAdapter({ + * name: "get-user", + * pathPattern: "/users/*", + * methods: ["GET"], + * input: (req) => ({ + * query: `query($id: ID!) { user(id: $id) { id name } }`, + * variables: { id: req.path.split("/")[2] }, + * }), + * output: (resp) => ({ + * statusCode: 200, + * headers: { "content-type": "application/json" }, + * body: JSON.stringify(resp.data), + * }), + * }); + */ +export function defineHttpAdapter(config: HttpAdapter): HttpAdapter { + return brandValue({ ...config }, "http-adapter"); +} diff --git a/packages/sdk/src/configure/services/http-adapter/index.ts b/packages/sdk/src/configure/services/http-adapter/index.ts new file mode 100644 index 000000000..5b0d0b888 --- /dev/null +++ b/packages/sdk/src/configure/services/http-adapter/index.ts @@ -0,0 +1 @@ +export * from "./http-adapter"; diff --git a/packages/sdk/src/configure/services/index.ts b/packages/sdk/src/configure/services/index.ts index 037468709..3958b9824 100644 --- a/packages/sdk/src/configure/services/index.ts +++ b/packages/sdk/src/configure/services/index.ts @@ -18,3 +18,4 @@ export * from "./workflow"; export * from "./staticwebsite"; export * from "./idp"; export * from "./secrets"; +export * from "./http-adapter"; diff --git a/packages/sdk/src/parser/service/http-adapter/index.ts b/packages/sdk/src/parser/service/http-adapter/index.ts new file mode 100644 index 000000000..686fbd9e9 --- /dev/null +++ b/packages/sdk/src/parser/service/http-adapter/index.ts @@ -0,0 +1 @@ +export * from "./schema"; diff --git a/packages/sdk/src/parser/service/http-adapter/schema.test.ts b/packages/sdk/src/parser/service/http-adapter/schema.test.ts new file mode 100644 index 000000000..21f32628c --- /dev/null +++ b/packages/sdk/src/parser/service/http-adapter/schema.test.ts @@ -0,0 +1,82 @@ +import { describe, expect, it } from "vitest"; +import { HttpAdapterConfigSchema, HttpAdapterServiceInputSchema } from "./schema"; + +const baseConfig = { + name: "get-user", + pathPattern: "/users/*", + methods: ["GET"], + input: (req: unknown) => ({ query: "{ me { id } }", variables: { req } }), +}; + +describe("HttpAdapterConfigSchema", () => { + it("accepts a minimal valid config", () => { + const result = HttpAdapterConfigSchema.safeParse(baseConfig); + expect(result.success).toBe(true); + if (result.success) { + expect(result.data.enabled).toBe(true); + expect(result.data.priority).toBe(0); + } + }); + + it("accepts a config with an output function", () => { + const result = HttpAdapterConfigSchema.safeParse({ + ...baseConfig, + output: () => ({ body: "" }), + }); + expect(result.success).toBe(true); + }); + + it("rejects a name that doesn't match the pattern", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, name: "Invalid Name" }); + expect(result.success).toBe(false); + }); + + it("rejects a name shorter than 3 chars", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, name: "ab" }); + expect(result.success).toBe(false); + }); + + it("rejects a name starting with a hyphen", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, name: "-foo" }); + expect(result.success).toBe(false); + }); + + it("rejects an empty methods array", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, methods: [] }); + expect(result.success).toBe(false); + }); + + it("rejects an unknown HTTP method", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, methods: ["WHATEVER"] }); + expect(result.success).toBe(false); + }); + + it("rejects an empty pathPattern", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, pathPattern: "" }); + expect(result.success).toBe(false); + }); + + it("rejects a missing input function", () => { + const { input: _omit, ...without } = baseConfig; + void _omit; + const result = HttpAdapterConfigSchema.safeParse(without); + expect(result.success).toBe(false); + }); + + it("rejects a non-function input", () => { + const result = HttpAdapterConfigSchema.safeParse({ ...baseConfig, input: "not a function" }); + expect(result.success).toBe(false); + }); +}); + +describe("HttpAdapterServiceInputSchema", () => { + it("accepts a config with files", () => { + const result = HttpAdapterServiceInputSchema.safeParse({ files: ["adapters/**/*.ts"] }); + expect(result.success).toBe(true); + }); + + it("rejects an empty files array", () => { + const result = HttpAdapterServiceInputSchema.safeParse({ files: [] }); + expect(result.success).toBe(false); + }); +}); diff --git a/packages/sdk/src/parser/service/http-adapter/schema.ts b/packages/sdk/src/parser/service/http-adapter/schema.ts new file mode 100644 index 000000000..91070f7a7 --- /dev/null +++ b/packages/sdk/src/parser/service/http-adapter/schema.ts @@ -0,0 +1,37 @@ +import { z } from "zod"; +import { functionSchema } from "../common"; + +const HTTP_METHODS = ["GET", "POST", "PUT", "PATCH", "DELETE", "OPTIONS", "HEAD"] as const; + +const NAME_PATTERN = /^[a-z0-9][a-z0-9-]{1,61}[a-z0-9]$/; + +export const HttpAdapterConfigSchema = z + .object({ + name: z + .string() + .regex( + NAME_PATTERN, + "name must be 3-63 chars, lowercase alphanumeric with hyphens, not starting or ending with a hyphen", + ) + .describe("Unique adapter name within the domain"), + pathPattern: z + .string() + .min(1) + .describe("Path pattern with segment wildcards (trailing or single-segment)"), + methods: z + .array(z.enum(HTTP_METHODS)) + .min(1, "methods must contain at least one HTTP method") + .describe("HTTP methods this adapter handles"), + enabled: z.boolean().default(true).describe("Whether the adapter is active"), + priority: z.number().int().default(0).describe("Matching priority"), + input: functionSchema.describe("Function that transforms HTTP request to GraphQL request"), + output: functionSchema + .optional() + .describe("Function that transforms GraphQL response to HTTP response"), + }) + .brand("HttpAdapterConfig"); + +export const HttpAdapterServiceInputSchema = z.object({ + files: z.array(z.string()).min(1).describe("Glob patterns matching HTTP adapter files"), + ignores: z.array(z.string()).optional().describe("Glob patterns to exclude"), +}); diff --git a/packages/sdk/src/types/app-config.ts b/packages/sdk/src/types/app-config.ts index 2f922e50d..27863edbc 100644 --- a/packages/sdk/src/types/app-config.ts +++ b/packages/sdk/src/types/app-config.ts @@ -1,4 +1,5 @@ import type { AuthConfig } from "./auth"; +import type { HttpAdapterServiceInput } from "./http-adapter"; import type { IdPConfig } from "./idp"; import type { SecretsConfig } from "./secrets-config"; import type { StaticWebsiteConfig } from "./staticwebsite-config"; @@ -70,6 +71,8 @@ export interface AppConfig< executor?: ExecutorServiceInput; /** Workflow service configuration with workflow files. */ workflow?: WorkflowServiceInput; + /** HTTP adapter service configuration with adapter files. */ + httpAdapter?: HttpAdapterServiceInput; /** Static website configurations. Must be an array, e.g. `[website]`. */ staticWebsites?: StaticWebsites; /** Secret Manager vault configurations. Keys are vault names, values are records of secret names to values. */ diff --git a/packages/sdk/src/types/http-adapter.generated.ts b/packages/sdk/src/types/http-adapter.generated.ts new file mode 100644 index 000000000..6511921d9 --- /dev/null +++ b/packages/sdk/src/types/http-adapter.generated.ts @@ -0,0 +1,43 @@ +// Generated by zinfer - Do not edit manually + +export type HttpAdapterConfigInput = { + /** Unique adapter name within the domain */ + name: string; + /** Path pattern with segment wildcards (trailing or single-segment) */ + pathPattern: string; + /** HTTP methods this adapter handles */ + methods: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD")[]; + /** Function that transforms HTTP request to GraphQL request */ + input: Function; + /** Whether the adapter is active */ + enabled?: boolean | undefined; + /** Matching priority */ + priority?: number | undefined; + /** Function that transforms GraphQL response to HTTP response */ + output?: Function | undefined; +}; + +export type HttpAdapterConfig = { + /** Unique adapter name within the domain */ + name: string; + /** Path pattern with segment wildcards (trailing or single-segment) */ + pathPattern: string; + /** HTTP methods this adapter handles */ + methods: ("GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD")[]; + /** Whether the adapter is active */ + enabled: boolean; + /** Matching priority */ + priority: number; + /** Function that transforms HTTP request to GraphQL request */ + input: Function; + /** Function that transforms GraphQL response to HTTP response */ + output?: Function | undefined; +}; + +export type HttpAdapterServiceInput = { + /** Glob patterns matching HTTP adapter files */ + files: string[]; + /** Glob patterns to exclude */ + ignores?: string[] | undefined; +}; +export type HttpAdapterServiceInputInput = HttpAdapterServiceInput; diff --git a/packages/sdk/src/types/http-adapter.ts b/packages/sdk/src/types/http-adapter.ts new file mode 100644 index 000000000..dbe1d5708 --- /dev/null +++ b/packages/sdk/src/types/http-adapter.ts @@ -0,0 +1,49 @@ +import type { HttpAdapterConfigInput } from "./http-adapter.generated"; + +export type { + HttpAdapterConfig, + HttpAdapterConfigInput, + HttpAdapterServiceInput, +} from "./http-adapter.generated"; + +export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE" | "OPTIONS" | "HEAD"; + +export type HttpAdapterRequest = { + method: HttpMethod; + path: string; + headers: Record; + query: Record; + body: string; +}; + +export type HttpAdapterInputResult = { + query: string; + variables?: Record; + operationName?: string; +}; + +export type HttpAdapterInputFn = (req: HttpAdapterRequest) => HttpAdapterInputResult; + +export type HttpAdapterGraphQLResponse = { + data?: unknown; + errors?: unknown; + extensions?: unknown; +}; + +export type HttpAdapterOutputResult = { + statusCode?: number; + headers?: Record; + body: string; +}; + +export type HttpAdapterOutputFn = (resp: HttpAdapterGraphQLResponse) => HttpAdapterOutputResult; + +/** + * User-facing HTTP adapter shape with typed `input` and `output` signatures. + * The runtime/parser representation uses the looser `HttpAdapterConfig` from + * `./http-adapter.generated` where these fields are typed as `Function`. + */ +export type HttpAdapter = Omit & { + input: HttpAdapterInputFn; + output?: HttpAdapterOutputFn; +}; diff --git a/packages/sdk/src/utils/brand.ts b/packages/sdk/src/utils/brand.ts index 2bced74d4..9c1010b6b 100644 --- a/packages/sdk/src/utils/brand.ts +++ b/packages/sdk/src/utils/brand.ts @@ -8,7 +8,8 @@ export type SdkBrandKind = | "executor" | "workflow" | "workflow-job" - | "wait-point"; + | "wait-point" + | "http-adapter"; /** * Adds a non-enumerable SDK brand symbol to the given object (in-place). diff --git a/packages/tailor-proto/src/tailor/v1/application_pb.d.ts b/packages/tailor-proto/src/tailor/v1/application_pb.d.ts index e1a3b0bab..c474563bd 100644 --- a/packages/tailor-proto/src/tailor/v1/application_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/application_pb.d.ts @@ -5,7 +5,7 @@ import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; import type { Application, ApplicationSchemaUpdateAttempt, Subgraph } from "./application_resource_pb"; -import type { GatewayFilter } from "./gateway_filter_resource_pb"; +import type { HttpAdapter } from "./http_adapter_resource_pb"; import type { FieldMask, Timestamp } from "@bufbuild/protobuf/wkt"; import type { PageDirection } from "./resource_pb"; @@ -68,9 +68,9 @@ export declare type CreateApplicationRequest = Message<"tailor.v1.CreateApplicat disabled: boolean; /** - * @generated from field: repeated tailor.v1.GatewayFilter filters = 10; + * @generated from field: repeated tailor.v1.HttpAdapter http_adapters = 10; */ - filters: GatewayFilter[]; + httpAdapters: HttpAdapter[]; }; /** @@ -149,9 +149,9 @@ export declare type UpdateApplicationRequest = Message<"tailor.v1.UpdateApplicat disabled: boolean; /** - * @generated from field: repeated tailor.v1.GatewayFilter filters = 10; + * @generated from field: repeated tailor.v1.HttpAdapter http_adapters = 10; */ - filters: GatewayFilter[]; + httpAdapters: HttpAdapter[]; /** * @generated from field: google.protobuf.FieldMask update_mask = 100; diff --git a/packages/tailor-proto/src/tailor/v1/application_pb.js b/packages/tailor-proto/src/tailor/v1/application_pb.js index fb0d32ba1..a410856a2 100644 --- a/packages/tailor-proto/src/tailor/v1/application_pb.js +++ b/packages/tailor-proto/src/tailor/v1/application_pb.js @@ -7,14 +7,14 @@ import { file_buf_validate_validate } from "../../buf/validate/validate_pb"; import { file_google_protobuf_field_mask, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; import { file_tailor_fieldmask_v1_option } from "../fieldmask/v1/option_pb"; import { file_tailor_v1_application_resource } from "./application_resource_pb"; -import { file_tailor_v1_gateway_filter_resource } from "./gateway_filter_resource_pb"; +import { file_tailor_v1_http_adapter_resource } from "./http_adapter_resource_pb"; import { file_tailor_v1_resource } from "./resource_pb"; /** * Describes the file tailor/v1/application.proto. */ export const file_tailor_v1_application = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_tailor_fieldmask_v1_option, file_tailor_v1_application_resource, file_tailor_v1_gateway_filter_resource, file_tailor_v1_resource]); + fileDesc("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", [file_buf_validate_validate, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_tailor_fieldmask_v1_option, file_tailor_v1_application_resource, file_tailor_v1_http_adapter_resource, file_tailor_v1_resource]); /** * Describes the message tailor.v1.CreateApplicationRequest. diff --git a/packages/tailor-proto/src/tailor/v1/application_resource_pb.d.ts b/packages/tailor-proto/src/tailor/v1/application_resource_pb.d.ts index be682ade2..ca72fe032 100644 --- a/packages/tailor-proto/src/tailor/v1/application_resource_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/application_resource_pb.d.ts @@ -5,7 +5,7 @@ import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; import type { Timestamp } from "@bufbuild/protobuf/wkt"; -import type { GatewayFilter } from "./gateway_filter_resource_pb"; +import type { HttpAdapter } from "./http_adapter_resource_pb"; /** * Describes the file tailor/v1/application_resource.proto. @@ -89,9 +89,9 @@ export declare type Application = Message<"tailor.v1.Application"> & { authIdpConfigName: string; /** - * @generated from field: repeated tailor.v1.GatewayFilter filters = 15; + * @generated from field: repeated tailor.v1.HttpAdapter http_adapters = 15; */ - filters: GatewayFilter[]; + httpAdapters: HttpAdapter[]; }; /** diff --git a/packages/tailor-proto/src/tailor/v1/application_resource_pb.js b/packages/tailor-proto/src/tailor/v1/application_resource_pb.js index 41703e20f..14c90ac2c 100644 --- a/packages/tailor-proto/src/tailor/v1/application_resource_pb.js +++ b/packages/tailor-proto/src/tailor/v1/application_resource_pb.js @@ -6,13 +6,13 @@ import { enumDesc, fileDesc, messageDesc, tsEnum } from "@bufbuild/protobuf/code import { file_buf_validate_validate } from "../../buf/validate/validate_pb"; import { file_google_api_field_behavior } from "../../google/api/field_behavior_pb"; import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; -import { file_tailor_v1_gateway_filter_resource } from "./gateway_filter_resource_pb"; +import { file_tailor_v1_http_adapter_resource } from "./http_adapter_resource_pb"; /** * Describes the file tailor/v1/application_resource.proto. */ export const file_tailor_v1_application_resource = /*@__PURE__*/ - fileDesc("CiR0YWlsb3IvdjEvYXBwbGljYXRpb25fcmVzb3VyY2UucHJvdG8SCXRhaWxvci52MSL7AwoLQXBwbGljYXRpb24SDAoEbmFtZRgBIAEoCRITCgZkb21haW4YAiABKAlCA+BBAxIWCg5hdXRoX25hbWVzcGFjZRgDIAEoCRIMCgRjb3JzGAQgAygJEhwKFGFsbG93ZWRfaXBfYWRkcmVzc2VzGAsgAygJEiYKCXN1YmdyYXBocxgFIAMoCzITLnRhaWxvci52MS5TdWJncmFwaBIbCg5jcmVhdGVfdXNlcl9pZBgGIAEoCUID4EEDEhsKDnVwZGF0ZV91c2VyX2lkGAcgASgJQgPgQQMSNAoLY3JlYXRlX3RpbWUYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYCSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSEAoDdXJsGAogASgJQgPgQQMSHQoVZGlzYWJsZV9pbnRyb3NwZWN0aW9uGAwgASgIEhAKCGRpc2FibGVkGA0gASgIEkkKFGF1dGhfaWRwX2NvbmZpZ19uYW1lGA4gASgJQiu6SChyJjIkXihbYS16MC05XVthLXowLTktXXsxLDYxfVthLXowLTldKT8kEikKB2ZpbHRlcnMYDyADKAsyGC50YWlsb3IudjEuR2F0ZXdheUZpbHRlciKiAQoeQXBwbGljYXRpb25TY2hlbWFVcGRhdGVBdHRlbXB0EjAKDGF0dGVtcHRfdGltZRgBIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXASPwoGc3RhdHVzGAIgASgOMi8udGFpbG9yLnYxLkFwcGxpY2F0aW9uU2NoZW1hVXBkYXRlQXR0ZW1wdFN0YXR1cxINCgVlcnJvchgDIAEoCSLIAgoIU3ViZ3JhcGgSNQoMc2VydmljZV90eXBlGAEgASgOMh8udGFpbG9yLnYxLlN1YmdyYXBoLlNlcnZpY2VUeXBlEkMKEXNlcnZpY2VfbmFtZXNwYWNlGAIgASgJQii6SCVyIzIhXlthLXowLTldW2EtejAtOS1dezEsNjF9W2EtejAtOV0kIr8BCgtTZXJ2aWNlVHlwZRIcChhTRVJWSUNFX1RZUEVfVU5TUEVDSUZJRUQQABIZChVTRVJWSUNFX1RZUEVfUElQRUxJTkUQARIaChZTRVJWSUNFX1RZUEVfU1RBVEVGTE9XEAISGQoVU0VSVklDRV9UWVBFX1RBSUxPUkRCEAMSFQoRU0VSVklDRV9UWVBFX0FVVEgQBBITCg9TRVJWSUNFX1RZUEVfQUkQBRIUChBTRVJWSUNFX1RZUEVfSURQEAYqzQEKJEFwcGxpY2F0aW9uU2NoZW1hVXBkYXRlQXR0ZW1wdFN0YXR1cxI4CjRBUFBMSUNBVElPTl9TQ0hFTUFfVVBEQVRFX0FUVEVNUFRfU1RBVFVTX1VOU1BFQ0lGSUVEEAASNgoyQVBQTElDQVRJT05fU0NIRU1BX1VQREFURV9BVFRFTVBUX1NUQVRVU19TVUNDRUVERUQQARIzCi9BUFBMSUNBVElPTl9TQ0hFTUFfVVBEQVRFX0FUVEVNUFRfU1RBVFVTX0ZBSUxFRBACYgZwcm90bzM", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_timestamp, file_tailor_v1_gateway_filter_resource]); + fileDesc("CiR0YWlsb3IvdjEvYXBwbGljYXRpb25fcmVzb3VyY2UucHJvdG8SCXRhaWxvci52MSL/AwoLQXBwbGljYXRpb24SDAoEbmFtZRgBIAEoCRITCgZkb21haW4YAiABKAlCA+BBAxIWCg5hdXRoX25hbWVzcGFjZRgDIAEoCRIMCgRjb3JzGAQgAygJEhwKFGFsbG93ZWRfaXBfYWRkcmVzc2VzGAsgAygJEiYKCXN1YmdyYXBocxgFIAMoCzITLnRhaWxvci52MS5TdWJncmFwaBIbCg5jcmVhdGVfdXNlcl9pZBgGIAEoCUID4EEDEhsKDnVwZGF0ZV91c2VyX2lkGAcgASgJQgPgQQMSNAoLY3JlYXRlX3RpbWUYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYCSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSEAoDdXJsGAogASgJQgPgQQMSHQoVZGlzYWJsZV9pbnRyb3NwZWN0aW9uGAwgASgIEhAKCGRpc2FibGVkGA0gASgIEkkKFGF1dGhfaWRwX2NvbmZpZ19uYW1lGA4gASgJQiu6SChyJjIkXihbYS16MC05XVthLXowLTktXXsxLDYxfVthLXowLTldKT8kEi0KDWh0dHBfYWRhcHRlcnMYDyADKAsyFi50YWlsb3IudjEuSHR0cEFkYXB0ZXIiogEKHkFwcGxpY2F0aW9uU2NoZW1hVXBkYXRlQXR0ZW1wdBIwCgxhdHRlbXB0X3RpbWUYASABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wEj8KBnN0YXR1cxgCIAEoDjIvLnRhaWxvci52MS5BcHBsaWNhdGlvblNjaGVtYVVwZGF0ZUF0dGVtcHRTdGF0dXMSDQoFZXJyb3IYAyABKAkiyAIKCFN1YmdyYXBoEjUKDHNlcnZpY2VfdHlwZRgBIAEoDjIfLnRhaWxvci52MS5TdWJncmFwaC5TZXJ2aWNlVHlwZRJDChFzZXJ2aWNlX25hbWVzcGFjZRgCIAEoCUIoukglciMyIV5bYS16MC05XVthLXowLTktXXsxLDYxfVthLXowLTldJCK/AQoLU2VydmljZVR5cGUSHAoYU0VSVklDRV9UWVBFX1VOU1BFQ0lGSUVEEAASGQoVU0VSVklDRV9UWVBFX1BJUEVMSU5FEAESGgoWU0VSVklDRV9UWVBFX1NUQVRFRkxPVxACEhkKFVNFUlZJQ0VfVFlQRV9UQUlMT1JEQhADEhUKEVNFUlZJQ0VfVFlQRV9BVVRIEAQSEwoPU0VSVklDRV9UWVBFX0FJEAUSFAoQU0VSVklDRV9UWVBFX0lEUBAGKs0BCiRBcHBsaWNhdGlvblNjaGVtYVVwZGF0ZUF0dGVtcHRTdGF0dXMSOAo0QVBQTElDQVRJT05fU0NIRU1BX1VQREFURV9BVFRFTVBUX1NUQVRVU19VTlNQRUNJRklFRBAAEjYKMkFQUExJQ0FUSU9OX1NDSEVNQV9VUERBVEVfQVRURU1QVF9TVEFUVVNfU1VDQ0VFREVEEAESMwovQVBQTElDQVRJT05fU0NIRU1BX1VQREFURV9BVFRFTVBUX1NUQVRVU19GQUlMRUQQAmIGcHJvdG8z", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_timestamp, file_tailor_v1_http_adapter_resource]); /** * Describes the message tailor.v1.Application. diff --git a/packages/tailor-proto/src/tailor/v1/gateway_filter_resource_pb.js b/packages/tailor-proto/src/tailor/v1/gateway_filter_resource_pb.js deleted file mode 100644 index 8f8d6eaec..000000000 --- a/packages/tailor-proto/src/tailor/v1/gateway_filter_resource_pb.js +++ /dev/null @@ -1,22 +0,0 @@ -// @generated by protoc-gen-es v2.6.3 -// @generated from file tailor/v1/gateway_filter_resource.proto (package tailor.v1, syntax proto3) -/* eslint-disable */ - -import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; -import { file_buf_validate_validate } from "../../buf/validate/validate_pb"; -import { file_google_api_field_behavior } from "../../google/api/field_behavior_pb"; -import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; - -/** - * Describes the file tailor/v1/gateway_filter_resource.proto. - */ -export const file_tailor_v1_gateway_filter_resource = /*@__PURE__*/ - fileDesc("Cid0YWlsb3IvdjEvZ2F0ZXdheV9maWx0ZXJfcmVzb3VyY2UucHJvdG8SCXRhaWxvci52MSLUAgoNR2F0ZXdheUZpbHRlchI2CgRuYW1lGAEgASgJQii6SCVyIzIhXlthLXowLTldW2EtejAtOS1dezEsNjF9W2EtejAtOV0kEh0KDHBhdGhfcGF0dGVybhgCIAEoCUIHukgEcgIQARIZCgdtZXRob2RzGAMgAygJQgi6SAWSAQIIARIkChNpbnB1dF9maWx0ZXJfc2NyaXB0GAQgASgJQge6SARyAhABEhwKFG91dHB1dF9maWx0ZXJfc2NyaXB0GAUgASgJEg8KB2VuYWJsZWQYBiABKAgSEAoIcHJpb3JpdHkYByABKAUSNAoLY3JlYXRlX3RpbWUYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYCSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQNiBnByb3RvMw", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_timestamp]); - -/** - * Describes the message tailor.v1.GatewayFilter. - * Use `create(GatewayFilterSchema)` to create a new message. - */ -export const GatewayFilterSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_gateway_filter_resource, 0); - diff --git a/packages/tailor-proto/src/tailor/v1/gateway_filter_resource_pb.d.ts b/packages/tailor-proto/src/tailor/v1/http_adapter_resource_pb.d.ts similarity index 56% rename from packages/tailor-proto/src/tailor/v1/gateway_filter_resource_pb.d.ts rename to packages/tailor-proto/src/tailor/v1/http_adapter_resource_pb.d.ts index 741599dc6..a31b7a336 100644 --- a/packages/tailor-proto/src/tailor/v1/gateway_filter_resource_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/http_adapter_resource_pb.d.ts @@ -1,5 +1,5 @@ // @generated by protoc-gen-es v2.6.3 -// @generated from file tailor/v1/gateway_filter_resource.proto (package tailor.v1, syntax proto3) +// @generated from file tailor/v1/http_adapter_resource.proto (package tailor.v1, syntax proto3) /* eslint-disable */ import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; @@ -7,14 +7,14 @@ import type { Message } from "@bufbuild/protobuf"; import type { Timestamp } from "@bufbuild/protobuf/wkt"; /** - * Describes the file tailor/v1/gateway_filter_resource.proto. + * Describes the file tailor/v1/http_adapter_resource.proto. */ -export declare const file_tailor_v1_gateway_filter_resource: GenFile; +export declare const file_tailor_v1_http_adapter_resource: GenFile; /** - * @generated from message tailor.v1.GatewayFilter + * @generated from message tailor.v1.HttpAdapter */ -export declare type GatewayFilter = Message<"tailor.v1.GatewayFilter"> & { +export declare type HttpAdapter = Message<"tailor.v1.HttpAdapter"> & { /** * @generated from field: string name = 1; */ @@ -31,16 +31,16 @@ export declare type GatewayFilter = Message<"tailor.v1.GatewayFilter"> & { methods: string[]; /** - * @generated from field: string input_filter_script = 4; + * @generated from field: string input_script = 4; */ - inputFilterScript: string; + inputScript: string; /** * optional * - * @generated from field: string output_filter_script = 5; + * @generated from field: string output_script = 5; */ - outputFilterScript: string; + outputScript: string; /** * @generated from field: bool enabled = 6; @@ -64,8 +64,8 @@ export declare type GatewayFilter = Message<"tailor.v1.GatewayFilter"> & { }; /** - * Describes the message tailor.v1.GatewayFilter. - * Use `create(GatewayFilterSchema)` to create a new message. + * Describes the message tailor.v1.HttpAdapter. + * Use `create(HttpAdapterSchema)` to create a new message. */ -export declare const GatewayFilterSchema: GenMessage; +export declare const HttpAdapterSchema: GenMessage; diff --git a/packages/tailor-proto/src/tailor/v1/http_adapter_resource_pb.js b/packages/tailor-proto/src/tailor/v1/http_adapter_resource_pb.js new file mode 100644 index 000000000..91f97ff03 --- /dev/null +++ b/packages/tailor-proto/src/tailor/v1/http_adapter_resource_pb.js @@ -0,0 +1,22 @@ +// @generated by protoc-gen-es v2.6.3 +// @generated from file tailor/v1/http_adapter_resource.proto (package tailor.v1, syntax proto3) +/* eslint-disable */ + +import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; +import { file_buf_validate_validate } from "../../buf/validate/validate_pb"; +import { file_google_api_field_behavior } from "../../google/api/field_behavior_pb"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; + +/** + * Describes the file tailor/v1/http_adapter_resource.proto. + */ +export const file_tailor_v1_http_adapter_resource = /*@__PURE__*/ + fileDesc("CiV0YWlsb3IvdjEvaHR0cF9hZGFwdGVyX3Jlc291cmNlLnByb3RvEgl0YWlsb3IudjEixAIKC0h0dHBBZGFwdGVyEjYKBG5hbWUYASABKAlCKLpIJXIjMiFeW2EtejAtOV1bYS16MC05LV17MSw2MX1bYS16MC05XSQSHQoMcGF0aF9wYXR0ZXJuGAIgASgJQge6SARyAhABEhkKB21ldGhvZHMYAyADKAlCCLpIBZIBAggBEh0KDGlucHV0X3NjcmlwdBgEIAEoCUIHukgEcgIQARIVCg1vdXRwdXRfc2NyaXB0GAUgASgJEg8KB2VuYWJsZWQYBiABKAgSEAoIcHJpb3JpdHkYByABKAUSNAoLY3JlYXRlX3RpbWUYCCABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSNAoLdXBkYXRlX3RpbWUYCSABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQNiBnByb3RvMw", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_timestamp]); + +/** + * Describes the message tailor.v1.HttpAdapter. + * Use `create(HttpAdapterSchema)` to create a new message. + */ +export const HttpAdapterSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_http_adapter_resource, 0); + diff --git a/packages/tailor-proto/src/tailor/v1/service_pb.d.ts b/packages/tailor-proto/src/tailor/v1/service_pb.d.ts index 67049e6c7..fe8a0fa6d 100644 --- a/packages/tailor-proto/src/tailor/v1/service_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/service_pb.d.ts @@ -4,7 +4,7 @@ import type { GenFile, GenMessage, GenService } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; -import type { AddOrganizationTeamMemberRequestSchema, AddOrganizationTeamMemberResponseSchema, CreateOrganizationFolderRequestSchema, CreateOrganizationFolderResponseSchema, CreateOrganizationTeamRequestSchema, CreateOrganizationTeamResponseSchema, CreateWorkspaceRequestSchema, CreateWorkspaceResponseSchema, DeleteOrganizationFolderRequestSchema, DeleteOrganizationFolderResponseSchema, DeleteOrganizationTeamRequestSchema, DeleteOrganizationTeamResponseSchema, DeleteWorkspaceRequestSchema, DeleteWorkspaceResponseSchema, GetOrganizationAccessRequestSchema, GetOrganizationAccessResponseSchema, GetOrganizationFolderAccessRequestSchema, GetOrganizationFolderAccessResponseSchema, GetOrganizationFolderRequestSchema, GetOrganizationFolderResponseSchema, GetOrganizationRequestSchema, GetOrganizationResponseSchema, GetOrganizationTeamMemberRequestSchema, GetOrganizationTeamMemberResponseSchema, GetOrganizationTeamRequestSchema, GetOrganizationTeamResponseSchema, GetPlatformAccountPlanRequestSchema, GetPlatformAccountPlanResponseSchema, GetWorkspacePlatformUserRequestSchema, GetWorkspacePlatformUserResponseSchema, GetWorkspaceRequestSchema, GetWorkspaceResponseSchema, GetWorkspaceRoleRequestSchema, GetWorkspaceRoleResponseSchema, GrantOrganizationAccessRequestSchema, GrantOrganizationAccessResponseSchema, GrantOrganizationFolderAccessRequestSchema, GrantOrganizationFolderAccessResponseSchema, InviteWorkspacePlatformUserRequestSchema, InviteWorkspacePlatformUserResponseSchema, ListAvailableWorkspacePlatformUserRolesRequestSchema, ListAvailableWorkspacePlatformUserRolesResponseSchema, ListAvailableWorkspaceRegionsRequestSchema, ListAvailableWorkspaceRegionsResponseSchema, ListOrganizationAccessesRequestSchema, ListOrganizationAccessesResponseSchema, ListOrganizationFolderAccessesRequestSchema, ListOrganizationFolderAccessesResponseSchema, ListOrganizationFoldersRequestSchema, ListOrganizationFoldersResponseSchema, ListOrganizationsRequestSchema, ListOrganizationsResponseSchema, ListOrganizationTeamMembersRequestSchema, ListOrganizationTeamMembersResponseSchema, ListOrganizationTeamsRequestSchema, ListOrganizationTeamsResponseSchema, ListOrganizationWorkspacesRequestSchema, ListOrganizationWorkspacesResponseSchema, ListUserOrganizationsRequestSchema, ListUserOrganizationsResponseSchema, ListWorkspacePlatformUsersRequestSchema, ListWorkspacePlatformUsersResponseSchema, ListWorkspacesRequestSchema, ListWorkspacesResponseSchema, RemoveOrganizationTeamMemberRequestSchema, RemoveOrganizationTeamMemberResponseSchema, RemoveWorkspacePlatformUserRequestSchema, RemoveWorkspacePlatformUserResponseSchema, RestoreWorkspaceRequestSchema, RestoreWorkspaceResponseSchema, RevokeOrganizationAccessRequestSchema, RevokeOrganizationAccessResponseSchema, RevokeOrganizationFolderAccessRequestSchema, RevokeOrganizationFolderAccessResponseSchema, UpdateOrganizationAccessRequestSchema, UpdateOrganizationAccessResponseSchema, UpdateOrganizationFolderAccessRequestSchema, UpdateOrganizationFolderAccessResponseSchema, UpdateOrganizationFolderRequestSchema, UpdateOrganizationFolderResponseSchema, UpdateOrganizationRequestSchema, UpdateOrganizationResponseSchema, UpdateOrganizationTeamMemberRequestSchema, UpdateOrganizationTeamMemberResponseSchema, UpdateOrganizationTeamRequestSchema, UpdateOrganizationTeamResponseSchema, UpdateWorkspacePlatformUserRequestSchema, UpdateWorkspacePlatformUserResponseSchema, UpdateWorkspaceRequestSchema, UpdateWorkspaceResponseSchema } from "./workspace_pb"; +import type { AddOrganizationTeamMemberRequestSchema, AddOrganizationTeamMemberResponseSchema, CreateOrganizationFolderRequestSchema, CreateOrganizationFolderResponseSchema, CreateOrganizationTeamRequestSchema, CreateOrganizationTeamResponseSchema, CreateWorkspaceRequestSchema, CreateWorkspaceResponseSchema, DeleteOrganizationFolderIPRestrictionRequestSchema, DeleteOrganizationFolderIPRestrictionResponseSchema, DeleteOrganizationFolderRequestSchema, DeleteOrganizationFolderResponseSchema, DeleteOrganizationIPRestrictionRequestSchema, DeleteOrganizationIPRestrictionResponseSchema, DeleteOrganizationTeamRequestSchema, DeleteOrganizationTeamResponseSchema, DeleteWorkspaceRequestSchema, DeleteWorkspaceResponseSchema, GetOrganizationAccessRequestSchema, GetOrganizationAccessResponseSchema, GetOrganizationFolderAccessRequestSchema, GetOrganizationFolderAccessResponseSchema, GetOrganizationFolderIPRestrictionRequestSchema, GetOrganizationFolderIPRestrictionResponseSchema, GetOrganizationFolderRequestSchema, GetOrganizationFolderResponseSchema, GetOrganizationIPRestrictionRequestSchema, GetOrganizationIPRestrictionResponseSchema, GetOrganizationRequestSchema, GetOrganizationResponseSchema, GetOrganizationTeamMemberRequestSchema, GetOrganizationTeamMemberResponseSchema, GetOrganizationTeamRequestSchema, GetOrganizationTeamResponseSchema, GetPlatformAccountPlanRequestSchema, GetPlatformAccountPlanResponseSchema, GetWorkspacePlatformUserRequestSchema, GetWorkspacePlatformUserResponseSchema, GetWorkspaceRequestSchema, GetWorkspaceResponseSchema, GetWorkspaceRoleRequestSchema, GetWorkspaceRoleResponseSchema, GrantOrganizationAccessRequestSchema, GrantOrganizationAccessResponseSchema, GrantOrganizationFolderAccessRequestSchema, GrantOrganizationFolderAccessResponseSchema, InviteWorkspacePlatformUserRequestSchema, InviteWorkspacePlatformUserResponseSchema, ListAvailableWorkspacePlatformUserRolesRequestSchema, ListAvailableWorkspacePlatformUserRolesResponseSchema, ListAvailableWorkspaceRegionsRequestSchema, ListAvailableWorkspaceRegionsResponseSchema, ListOrganizationAccessesRequestSchema, ListOrganizationAccessesResponseSchema, ListOrganizationFolderAccessesRequestSchema, ListOrganizationFolderAccessesResponseSchema, ListOrganizationFoldersRequestSchema, ListOrganizationFoldersResponseSchema, ListOrganizationsRequestSchema, ListOrganizationsResponseSchema, ListOrganizationTeamMembersRequestSchema, ListOrganizationTeamMembersResponseSchema, ListOrganizationTeamsRequestSchema, ListOrganizationTeamsResponseSchema, ListOrganizationWorkspacesRequestSchema, ListOrganizationWorkspacesResponseSchema, ListUserOrganizationsRequestSchema, ListUserOrganizationsResponseSchema, ListWorkspacePlatformUsersRequestSchema, ListWorkspacePlatformUsersResponseSchema, ListWorkspacesRequestSchema, ListWorkspacesResponseSchema, RemoveOrganizationTeamMemberRequestSchema, RemoveOrganizationTeamMemberResponseSchema, RemoveWorkspacePlatformUserRequestSchema, RemoveWorkspacePlatformUserResponseSchema, RestoreWorkspaceRequestSchema, RestoreWorkspaceResponseSchema, RevokeOrganizationAccessRequestSchema, RevokeOrganizationAccessResponseSchema, RevokeOrganizationFolderAccessRequestSchema, RevokeOrganizationFolderAccessResponseSchema, UpdateOrganizationAccessRequestSchema, UpdateOrganizationAccessResponseSchema, UpdateOrganizationFolderAccessRequestSchema, UpdateOrganizationFolderAccessResponseSchema, UpdateOrganizationFolderRequestSchema, UpdateOrganizationFolderResponseSchema, UpdateOrganizationRequestSchema, UpdateOrganizationResponseSchema, UpdateOrganizationTeamMemberRequestSchema, UpdateOrganizationTeamMemberResponseSchema, UpdateOrganizationTeamRequestSchema, UpdateOrganizationTeamResponseSchema, UpdateWorkspacePlatformUserRequestSchema, UpdateWorkspacePlatformUserResponseSchema, UpdateWorkspaceRequestSchema, UpdateWorkspaceResponseSchema, UpsertOrganizationFolderIPRestrictionRequestSchema, UpsertOrganizationFolderIPRestrictionResponseSchema, UpsertOrganizationIPRestrictionRequestSchema, UpsertOrganizationIPRestrictionResponseSchema } from "./workspace_pb"; import type { CreateApplicationRequestSchema, CreateApplicationResponseSchema, DeleteApplicationRequestSchema, DeleteApplicationResponseSchema, GetApplicationRequestSchema, GetApplicationResponseSchema, GetApplicationSchemaHealthRequestSchema, GetApplicationSchemaHealthResponseSchema, ListApplicationsRequestSchema, ListApplicationsResponseSchema, UpdateApplicationRequestSchema, UpdateApplicationResponseSchema } from "./application_pb"; import type { ComposeTailorDBSDLRequestSchema, ComposeTailorDBSDLResponseSchema, CreateTailorDBGQLPermissionRequestSchema, CreateTailorDBGQLPermissionResponseSchema, CreateTailorDBServiceRequestSchema, CreateTailorDBServiceResponseSchema, CreateTailorDBTypeRequestSchema, CreateTailorDBTypeResponseSchema, DeleteTailorDBGQLPermissionRequestSchema, DeleteTailorDBGQLPermissionResponseSchema, DeleteTailorDBServiceRequestSchema, DeleteTailorDBServiceResponseSchema, DeleteTailorDBTypeRequestSchema, DeleteTailorDBTypeResponseSchema, GetTailorDBGQLPermissionRequestSchema, GetTailorDBGQLPermissionResponseSchema, GetTailorDBServiceRequestSchema, GetTailorDBServiceResponseSchema, GetTailorDBTypeRequestSchema, GetTailorDBTypeResponseSchema, ListTailorDBGQLPermissionsRequestSchema, ListTailorDBGQLPermissionsResponseSchema, ListTailorDBServicesRequestSchema, ListTailorDBServicesResponseSchema, ListTailorDBTypesRequestSchema, ListTailorDBTypesResponseSchema, TruncateTailorDBTypeRequestSchema, TruncateTailorDBTypeResponseSchema, TruncateTailorDBTypesRequestSchema, TruncateTailorDBTypesResponseSchema, UpdateTailorDBGQLPermissionRequestSchema, UpdateTailorDBGQLPermissionResponseSchema, UpdateTailorDBServiceRequestSchema, UpdateTailorDBServiceResponseSchema, UpdateTailorDBTypeRequestSchema, UpdateTailorDBTypeResponseSchema } from "./tailordb_pb"; import type { ComposePipelineSDLRequestSchema, ComposePipelineSDLResponseSchema, CreatePipelineResolverRequestSchema, CreatePipelineResolverResponseSchema, CreatePipelineServiceRequestSchema, CreatePipelineServiceResponseSchema, DeletePipelineResolverRequestSchema, DeletePipelineResolverResponseSchema, DeletePipelineServiceRequestSchema, DeletePipelineServiceResponseSchema, GetPipelineResolverExecutionResultRequestSchema, GetPipelineResolverExecutionResultResponseSchema, GetPipelineResolverRequestSchema, GetPipelineResolverResponseSchema, GetPipelineServiceRequestSchema, GetPipelineServiceResponseSchema, ListPipelineResolverExecutionResultsRequestSchema, ListPipelineResolverExecutionResultsResponseSchema, ListPipelineResolversRequestSchema, ListPipelineResolversResponseSchema, ListPipelineServicesRequestSchema, ListPipelineServicesResponseSchema, RestartPipelineResolverRequestSchema, RestartPipelineResolverResponseSchema, UpdatePipelineResolverRequestSchema, UpdatePipelineResolverResponseSchema, UpdatePipelineServiceRequestSchema, UpdatePipelineServiceResponseSchema } from "./pipeline_pb"; @@ -17,8 +17,8 @@ import type { GetFunctionExecutionRequestSchema, GetFunctionExecutionResponseSch import type { CreateFunctionRegistryRequestSchema, CreateFunctionRegistryResponseSchema, DeleteFunctionRegistryRequestSchema, DeleteFunctionRegistryResponseSchema, DownloadFunctionRegistryScriptRequestSchema, DownloadFunctionRegistryScriptResponseSchema, GetFunctionRegistryRequestSchema, GetFunctionRegistryResponseSchema, ListFunctionRegistriesRequestSchema, ListFunctionRegistriesResponseSchema, UpdateFunctionRegistryRequestSchema, UpdateFunctionRegistryResponseSchema } from "./function_registry_pb"; import type { ListMeterEventCountsRequestSchema, ListMeterEventCountsResponseSchema, ListMeterExecutionCountsRequestSchema, ListMeterExecutionCountsResponseSchema, ListMeterRequestCountsRequestSchema, ListMeterRequestCountsResponseSchema } from "./meter_pb"; import type { CreateIdPClientRequestSchema, CreateIdPClientResponseSchema, CreateIdPServiceRequestSchema, CreateIdPServiceResponseSchema, DeleteIdPClientRequestSchema, DeleteIdPClientResponseSchema, DeleteIdPServiceRequestSchema, DeleteIdPServiceResponseSchema, GetIdPClientRequestSchema, GetIdPClientResponseSchema, GetIdPServiceRequestSchema, GetIdPServiceResponseSchema, ListIdPClientsRequestSchema, ListIdPClientsResponseSchema, ListIdPServicesRequestSchema, ListIdPServicesResponseSchema, UpdateIdPServiceRequestSchema, UpdateIdPServiceResponseSchema } from "./idp_pb"; -import type { CreateDeploymentRequestSchema, CreateDeploymentResponseSchema, CreateStaticWebsiteRequestSchema, CreateStaticWebsiteResponseSchema, DeleteStaticWebsiteRequestSchema, DeleteStaticWebsiteResponseSchema, GetStaticWebsiteRequestSchema, GetStaticWebsiteResponseSchema, ListStaticWebsitesRequestSchema, ListStaticWebsitesResponseSchema, PublishDeploymentRequestSchema, PublishDeploymentResponseSchema, UpdateStaticWebsiteRequestSchema, UpdateStaticWebsiteResponseSchema, UploadFileRequestSchema, UploadFileResponseSchema } from "./staticwebsite_pb"; -import type { CreateWorkflowJobFunctionRequestSchema, CreateWorkflowJobFunctionResponseSchema, CreateWorkflowRequestSchema, CreateWorkflowResponseSchema, DeleteWorkflowRequestSchema, DeleteWorkflowResponseSchema, GetWorkflowByNameRequestSchema, GetWorkflowByNameResponseSchema, GetWorkflowExecutionRequestSchema, GetWorkflowExecutionResponseSchema, GetWorkflowJobFunctionByNameRequestSchema, GetWorkflowJobFunctionByNameResponseSchema, GetWorkflowJobFunctionRequestSchema, GetWorkflowJobFunctionResponseSchema, GetWorkflowRequestSchema, GetWorkflowResponseSchema, ListWorkflowExecutionsRequestSchema, ListWorkflowExecutionsResponseSchema, ListWorkflowJobFunctionsRequestSchema, ListWorkflowJobFunctionsResponseSchema, ListWorkflowsRequestSchema, ListWorkflowsResponseSchema, TestResumeWorkflowRequestSchema, TestResumeWorkflowResponseSchema, TestStartWorkflowRequestSchema, TestStartWorkflowResponseSchema, UpdateWorkflowJobFunctionRequestSchema, UpdateWorkflowJobFunctionResponseSchema, UpdateWorkflowRequestSchema, UpdateWorkflowResponseSchema } from "./workflow_pb"; +import type { AddCustomDomainRequestSchema, AddCustomDomainResponseSchema, CreateDeploymentRequestSchema, CreateDeploymentResponseSchema, CreateStaticWebsiteRequestSchema, CreateStaticWebsiteResponseSchema, DeleteStaticWebsiteRequestSchema, DeleteStaticWebsiteResponseSchema, GetCustomDomainRequestSchema, GetCustomDomainResponseSchema, GetStaticWebsiteRequestSchema, GetStaticWebsiteResponseSchema, ListCustomDomainsRequestSchema, ListCustomDomainsResponseSchema, ListStaticWebsitesRequestSchema, ListStaticWebsitesResponseSchema, PublishDeploymentRequestSchema, PublishDeploymentResponseSchema, RemoveCustomDomainRequestSchema, RemoveCustomDomainResponseSchema, UpdateStaticWebsiteRequestSchema, UpdateStaticWebsiteResponseSchema, UploadFileRequestSchema, UploadFileResponseSchema } from "./staticwebsite_pb"; +import type { CreateWorkflowJobFunctionExecutionPolicyRequestSchema, CreateWorkflowJobFunctionExecutionPolicyResponseSchema, CreateWorkflowJobFunctionRequestSchema, CreateWorkflowJobFunctionResponseSchema, CreateWorkflowRequestSchema, CreateWorkflowResponseSchema, DeleteWorkflowJobFunctionExecutionPolicyRequestSchema, DeleteWorkflowJobFunctionExecutionPolicyResponseSchema, DeleteWorkflowRequestSchema, DeleteWorkflowResponseSchema, GetWorkflowByNameRequestSchema, GetWorkflowByNameResponseSchema, GetWorkflowExecutionRequestSchema, GetWorkflowExecutionResponseSchema, GetWorkflowJobFunctionByNameRequestSchema, GetWorkflowJobFunctionByNameResponseSchema, GetWorkflowJobFunctionExecutionPolicyByKeyRequestSchema, GetWorkflowJobFunctionExecutionPolicyByKeyResponseSchema, GetWorkflowJobFunctionExecutionPolicyRequestSchema, GetWorkflowJobFunctionExecutionPolicyResponseSchema, GetWorkflowJobFunctionRequestSchema, GetWorkflowJobFunctionResponseSchema, GetWorkflowRequestSchema, GetWorkflowResponseSchema, ListWorkflowExecutionsRequestSchema, ListWorkflowExecutionsResponseSchema, ListWorkflowJobFunctionExecutionPoliciesRequestSchema, ListWorkflowJobFunctionExecutionPoliciesResponseSchema, ListWorkflowJobFunctionsRequestSchema, ListWorkflowJobFunctionsResponseSchema, ListWorkflowsRequestSchema, ListWorkflowsResponseSchema, TestResumeWorkflowRequestSchema, TestResumeWorkflowResponseSchema, TestStartWorkflowRequestSchema, TestStartWorkflowResponseSchema, UpdateWorkflowJobFunctionExecutionPolicyRequestSchema, UpdateWorkflowJobFunctionExecutionPolicyResponseSchema, UpdateWorkflowJobFunctionRequestSchema, UpdateWorkflowJobFunctionResponseSchema, UpdateWorkflowRequestSchema, UpdateWorkflowResponseSchema } from "./workflow_pb"; import type { GetMetadataRequestSchema, GetMetadataResponseSchema, SetMetadataRequestSchema, SetMetadataResponseSchema } from "./metadata_pb"; import type { CreateResourceAttributesConfigRequestSchema, CreateResourceAttributesConfigResponseSchema, CreateTelemetryExportRequestSchema, CreateTelemetryExportResponseSchema, DeleteResourceAttributesConfigRequestSchema, DeleteResourceAttributesConfigResponseSchema, DeleteTelemetryExportRequestSchema, DeleteTelemetryExportResponseSchema, GetResourceAttributesConfigRequestSchema, GetResourceAttributesConfigResponseSchema, GetTelemetryExportRequestSchema, GetTelemetryExportResponseSchema, ListTelemetryExportsRequestSchema, ListTelemetryExportsResponseSchema, TestTelemetryExportRequestSchema, TestTelemetryExportResponseSchema, UpdateResourceAttributesConfigRequestSchema, UpdateResourceAttributesConfigResponseSchema, UpdateTelemetryExportRequestSchema, UpdateTelemetryExportResponseSchema } from "./telemetryrouter_pb"; @@ -576,6 +576,109 @@ export declare const OperatorService: GenService<{ input: typeof GetOrganizationFolderAccessRequestSchema; output: typeof GetOrganizationFolderAccessResponseSchema; }, + /** + * UpsertOrganizationIPRestriction creates or replaces the IP allowlist + * applied to all inbound dataplane traffic for an organization. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid (malformed CIDR, private / + * loopback / multicast address, etc.) + * - PermissionDenied: caller does not have permission on the organization + * - NotFound: organization does not exist or can not be accessed + * + * @generated from rpc tailor.v1.OperatorService.UpsertOrganizationIPRestriction + */ + upsertOrganizationIPRestriction: { + methodKind: "unary"; + input: typeof UpsertOrganizationIPRestrictionRequestSchema; + output: typeof UpsertOrganizationIPRestrictionResponseSchema; + }, + /** + * GetOrganizationIPRestriction returns the current IP allowlist for an + * organization, or NotFound if no rule is configured. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - PermissionDenied: caller does not have permission on the organization + * - NotFound: no IP restriction is configured for the organization + * + * @generated from rpc tailor.v1.OperatorService.GetOrganizationIPRestriction + */ + getOrganizationIPRestriction: { + methodKind: "unary"; + input: typeof GetOrganizationIPRestrictionRequestSchema; + output: typeof GetOrganizationIPRestrictionResponseSchema; + }, + /** + * DeleteOrganizationIPRestriction removes the IP allowlist for an + * organization. NotFound is returned if no rule is configured. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - PermissionDenied: caller does not have permission on the organization + * - NotFound: no IP restriction is configured for the organization + * + * @generated from rpc tailor.v1.OperatorService.DeleteOrganizationIPRestriction + */ + deleteOrganizationIPRestriction: { + methodKind: "unary"; + input: typeof DeleteOrganizationIPRestrictionRequestSchema; + output: typeof DeleteOrganizationIPRestrictionResponseSchema; + }, + /** + * UpsertOrganizationFolderIPRestriction creates or replaces the IP + * allowlist applied to all inbound dataplane traffic for a folder. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - PermissionDenied: caller does not have permission on the folder + * - NotFound: folder does not exist or can not be accessed + * + * @generated from rpc tailor.v1.OperatorService.UpsertOrganizationFolderIPRestriction + */ + upsertOrganizationFolderIPRestriction: { + methodKind: "unary"; + input: typeof UpsertOrganizationFolderIPRestrictionRequestSchema; + output: typeof UpsertOrganizationFolderIPRestrictionResponseSchema; + }, + /** + * GetOrganizationFolderIPRestriction returns the current IP allowlist + * for a folder, or NotFound if no rule is configured. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - PermissionDenied: caller does not have permission on the folder + * - NotFound: no IP restriction is configured for the folder + * + * @generated from rpc tailor.v1.OperatorService.GetOrganizationFolderIPRestriction + */ + getOrganizationFolderIPRestriction: { + methodKind: "unary"; + input: typeof GetOrganizationFolderIPRestrictionRequestSchema; + output: typeof GetOrganizationFolderIPRestrictionResponseSchema; + }, + /** + * DeleteOrganizationFolderIPRestriction removes the IP allowlist for a + * folder. NotFound is returned if no rule is configured. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - PermissionDenied: caller does not have permission on the folder + * - NotFound: no IP restriction is configured for the folder + * + * @generated from rpc tailor.v1.OperatorService.DeleteOrganizationFolderIPRestriction + */ + deleteOrganizationFolderIPRestriction: { + methodKind: "unary"; + input: typeof DeleteOrganizationFolderIPRestrictionRequestSchema; + output: typeof DeleteOrganizationFolderIPRestrictionResponseSchema; + }, /** * CreateOrganizationTeam creates a team in an organization. * @@ -2644,6 +2747,68 @@ export declare const OperatorService: GenService<{ input: typeof ListStaticWebsitesRequestSchema; output: typeof ListStaticWebsitesResponseSchema; }, + /** + * AddCustomDomain registers a custom domain for a static website. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: static website does not exist + * - AlreadyExists: domain is already registered + * - ResourceExhausted: maximum number of custom domains reached + * + * @generated from rpc tailor.v1.OperatorService.AddCustomDomain + */ + addCustomDomain: { + methodKind: "unary"; + input: typeof AddCustomDomainRequestSchema; + output: typeof AddCustomDomainResponseSchema; + }, + /** + * GetCustomDomain gets a custom domain. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: custom domain does not exist + * + * @generated from rpc tailor.v1.OperatorService.GetCustomDomain + */ + getCustomDomain: { + methodKind: "unary"; + input: typeof GetCustomDomainRequestSchema; + output: typeof GetCustomDomainResponseSchema; + }, + /** + * ListCustomDomains lists custom domains for a static website. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: static website does not exist + * + * @generated from rpc tailor.v1.OperatorService.ListCustomDomains + */ + listCustomDomains: { + methodKind: "unary"; + input: typeof ListCustomDomainsRequestSchema; + output: typeof ListCustomDomainsResponseSchema; + }, + /** + * RemoveCustomDomain removes a custom domain. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: custom domain does not exist + * + * @generated from rpc tailor.v1.OperatorService.RemoveCustomDomain + */ + removeCustomDomain: { + methodKind: "unary"; + input: typeof RemoveCustomDomainRequestSchema; + output: typeof RemoveCustomDomainResponseSchema; + }, /** * CreateDeployment creates a new deployment. * @@ -2912,6 +3077,95 @@ export declare const OperatorService: GenService<{ input: typeof TestResumeWorkflowRequestSchema; output: typeof TestResumeWorkflowResponseSchema; }, + /** + * CreateWorkflowJobFunctionExecutionPolicy creates a new workflow job function execution policy. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - AlreadyExists: policy already exists with the given execution_policy_key + * + * @generated from rpc tailor.v1.OperatorService.CreateWorkflowJobFunctionExecutionPolicy + */ + createWorkflowJobFunctionExecutionPolicy: { + methodKind: "unary"; + input: typeof CreateWorkflowJobFunctionExecutionPolicyRequestSchema; + output: typeof CreateWorkflowJobFunctionExecutionPolicyResponseSchema; + }, + /** + * UpdateWorkflowJobFunctionExecutionPolicy updates a workflow job function execution policy. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: policy does not exist or can not be accessed + * + * @generated from rpc tailor.v1.OperatorService.UpdateWorkflowJobFunctionExecutionPolicy + */ + updateWorkflowJobFunctionExecutionPolicy: { + methodKind: "unary"; + input: typeof UpdateWorkflowJobFunctionExecutionPolicyRequestSchema; + output: typeof UpdateWorkflowJobFunctionExecutionPolicyResponseSchema; + }, + /** + * DeleteWorkflowJobFunctionExecutionPolicy deletes a workflow job function execution policy. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: policy does not exist or can not be accessed + * + * @generated from rpc tailor.v1.OperatorService.DeleteWorkflowJobFunctionExecutionPolicy + */ + deleteWorkflowJobFunctionExecutionPolicy: { + methodKind: "unary"; + input: typeof DeleteWorkflowJobFunctionExecutionPolicyRequestSchema; + output: typeof DeleteWorkflowJobFunctionExecutionPolicyResponseSchema; + }, + /** + * GetWorkflowJobFunctionExecutionPolicy returns a workflow job function execution policy. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: policy does not exist or can not be accessed + * + * @generated from rpc tailor.v1.OperatorService.GetWorkflowJobFunctionExecutionPolicy + */ + getWorkflowJobFunctionExecutionPolicy: { + methodKind: "unary"; + input: typeof GetWorkflowJobFunctionExecutionPolicyRequestSchema; + output: typeof GetWorkflowJobFunctionExecutionPolicyResponseSchema; + }, + /** + * GetWorkflowJobFunctionExecutionPolicyByKey returns a workflow job function execution policy by its key. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * - NotFound: policy does not exist or can not be accessed + * + * @generated from rpc tailor.v1.OperatorService.GetWorkflowJobFunctionExecutionPolicyByKey + */ + getWorkflowJobFunctionExecutionPolicyByKey: { + methodKind: "unary"; + input: typeof GetWorkflowJobFunctionExecutionPolicyByKeyRequestSchema; + output: typeof GetWorkflowJobFunctionExecutionPolicyByKeyResponseSchema; + }, + /** + * ListWorkflowJobFunctionExecutionPolicies returns workflow job function execution policies in a given workspace. + * + * [Errors] + * - Unauthenticated: token is missing, expired, or invalid + * - InvalidArgument: request is invalid + * + * @generated from rpc tailor.v1.OperatorService.ListWorkflowJobFunctionExecutionPolicies + */ + listWorkflowJobFunctionExecutionPolicies: { + methodKind: "unary"; + input: typeof ListWorkflowJobFunctionExecutionPoliciesRequestSchema; + output: typeof ListWorkflowJobFunctionExecutionPoliciesResponseSchema; + }, /** * SetMetadata sets metadata labels for a resource. * diff --git a/packages/tailor-proto/src/tailor/v1/service_pb.js b/packages/tailor-proto/src/tailor/v1/service_pb.js index 38d5353c7..5776399bd 100644 --- a/packages/tailor-proto/src/tailor/v1/service_pb.js +++ b/packages/tailor-proto/src/tailor/v1/service_pb.js @@ -25,7 +25,7 @@ import { file_tailor_v1_workspace } from "./workspace_pb"; * Describes the file tailor/v1/service.proto. */ export const file_tailor_v1_service = /*@__PURE__*/ - fileDesc("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", [file_tailor_v1_application, file_tailor_v1_auth, file_tailor_v1_events, file_tailor_v1_executor, file_tailor_v1_function, file_tailor_v1_function_registry, file_tailor_v1_idp, file_tailor_v1_metadata, file_tailor_v1_meter, file_tailor_v1_pipeline, file_tailor_v1_secret_manager, file_tailor_v1_stateflow, file_tailor_v1_staticwebsite, file_tailor_v1_tailordb, file_tailor_v1_telemetryrouter, file_tailor_v1_workflow, file_tailor_v1_workspace]); + fileDesc("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", [file_tailor_v1_application, file_tailor_v1_auth, file_tailor_v1_events, file_tailor_v1_executor, file_tailor_v1_function, file_tailor_v1_function_registry, file_tailor_v1_idp, file_tailor_v1_metadata, file_tailor_v1_meter, file_tailor_v1_pipeline, file_tailor_v1_secret_manager, file_tailor_v1_stateflow, file_tailor_v1_staticwebsite, file_tailor_v1_tailordb, file_tailor_v1_telemetryrouter, file_tailor_v1_workflow, file_tailor_v1_workspace]); /** * Describes the message tailor.v1.PingRequest. diff --git a/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.d.ts b/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.d.ts index 5103a4b00..4bdaf6e15 100644 --- a/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.d.ts @@ -4,7 +4,7 @@ import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; -import type { StaticWebsite } from "./staticwebsite_resource_pb"; +import type { CustomDomain, StaticWebsite } from "./staticwebsite_resource_pb"; import type { PageDirection } from "./resource_pb"; /** @@ -358,3 +358,152 @@ export declare type PublishDeploymentResponse = Message<"tailor.v1.PublishDeploy */ export declare const PublishDeploymentResponseSchema: GenMessage; +/** + * @generated from message tailor.v1.AddCustomDomainRequest + */ +export declare type AddCustomDomainRequest = Message<"tailor.v1.AddCustomDomainRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string static_website_name = 2; + */ + staticWebsiteName: string; + + /** + * @generated from field: string domain = 3; + */ + domain: string; +}; + +/** + * Describes the message tailor.v1.AddCustomDomainRequest. + * Use `create(AddCustomDomainRequestSchema)` to create a new message. + */ +export declare const AddCustomDomainRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.AddCustomDomainResponse + */ +export declare type AddCustomDomainResponse = Message<"tailor.v1.AddCustomDomainResponse"> & { + /** + * @generated from field: tailor.v1.CustomDomain custom_domain = 1; + */ + customDomain?: CustomDomain; +}; + +/** + * Describes the message tailor.v1.AddCustomDomainResponse. + * Use `create(AddCustomDomainResponseSchema)` to create a new message. + */ +export declare const AddCustomDomainResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetCustomDomainRequest + */ +export declare type GetCustomDomainRequest = Message<"tailor.v1.GetCustomDomainRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string domain = 2; + */ + domain: string; +}; + +/** + * Describes the message tailor.v1.GetCustomDomainRequest. + * Use `create(GetCustomDomainRequestSchema)` to create a new message. + */ +export declare const GetCustomDomainRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetCustomDomainResponse + */ +export declare type GetCustomDomainResponse = Message<"tailor.v1.GetCustomDomainResponse"> & { + /** + * @generated from field: tailor.v1.CustomDomain custom_domain = 1; + */ + customDomain?: CustomDomain; +}; + +/** + * Describes the message tailor.v1.GetCustomDomainResponse. + * Use `create(GetCustomDomainResponseSchema)` to create a new message. + */ +export declare const GetCustomDomainResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.ListCustomDomainsRequest + */ +export declare type ListCustomDomainsRequest = Message<"tailor.v1.ListCustomDomainsRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string static_website_name = 2; + */ + staticWebsiteName: string; +}; + +/** + * Describes the message tailor.v1.ListCustomDomainsRequest. + * Use `create(ListCustomDomainsRequestSchema)` to create a new message. + */ +export declare const ListCustomDomainsRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.ListCustomDomainsResponse + */ +export declare type ListCustomDomainsResponse = Message<"tailor.v1.ListCustomDomainsResponse"> & { + /** + * @generated from field: repeated tailor.v1.CustomDomain custom_domains = 1; + */ + customDomains: CustomDomain[]; +}; + +/** + * Describes the message tailor.v1.ListCustomDomainsResponse. + * Use `create(ListCustomDomainsResponseSchema)` to create a new message. + */ +export declare const ListCustomDomainsResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.RemoveCustomDomainRequest + */ +export declare type RemoveCustomDomainRequest = Message<"tailor.v1.RemoveCustomDomainRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string domain = 2; + */ + domain: string; +}; + +/** + * Describes the message tailor.v1.RemoveCustomDomainRequest. + * Use `create(RemoveCustomDomainRequestSchema)` to create a new message. + */ +export declare const RemoveCustomDomainRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.RemoveCustomDomainResponse + */ +export declare type RemoveCustomDomainResponse = Message<"tailor.v1.RemoveCustomDomainResponse"> & { +}; + +/** + * Describes the message tailor.v1.RemoveCustomDomainResponse. + * Use `create(RemoveCustomDomainResponseSchema)` to create a new message. + */ +export declare const RemoveCustomDomainResponseSchema: GenMessage; + diff --git a/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.js b/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.js index 3c8316e82..a5ca6af2f 100644 --- a/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.js +++ b/packages/tailor-proto/src/tailor/v1/staticwebsite_pb.js @@ -11,7 +11,7 @@ import { file_tailor_v1_staticwebsite_resource } from "./staticwebsite_resource_ * Describes the file tailor/v1/staticwebsite.proto. */ export const file_tailor_v1_staticwebsite = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_tailor_v1_resource, file_tailor_v1_staticwebsite_resource]); + fileDesc("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", [file_buf_validate_validate, file_tailor_v1_resource, file_tailor_v1_staticwebsite_resource]); /** * Describes the message tailor.v1.CreateStaticWebsiteRequest. @@ -132,3 +132,59 @@ export const PublishDeploymentRequestSchema = /*@__PURE__*/ export const PublishDeploymentResponseSchema = /*@__PURE__*/ messageDesc(file_tailor_v1_staticwebsite, 15); +/** + * Describes the message tailor.v1.AddCustomDomainRequest. + * Use `create(AddCustomDomainRequestSchema)` to create a new message. + */ +export const AddCustomDomainRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 16); + +/** + * Describes the message tailor.v1.AddCustomDomainResponse. + * Use `create(AddCustomDomainResponseSchema)` to create a new message. + */ +export const AddCustomDomainResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 17); + +/** + * Describes the message tailor.v1.GetCustomDomainRequest. + * Use `create(GetCustomDomainRequestSchema)` to create a new message. + */ +export const GetCustomDomainRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 18); + +/** + * Describes the message tailor.v1.GetCustomDomainResponse. + * Use `create(GetCustomDomainResponseSchema)` to create a new message. + */ +export const GetCustomDomainResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 19); + +/** + * Describes the message tailor.v1.ListCustomDomainsRequest. + * Use `create(ListCustomDomainsRequestSchema)` to create a new message. + */ +export const ListCustomDomainsRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 20); + +/** + * Describes the message tailor.v1.ListCustomDomainsResponse. + * Use `create(ListCustomDomainsResponseSchema)` to create a new message. + */ +export const ListCustomDomainsResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 21); + +/** + * Describes the message tailor.v1.RemoveCustomDomainRequest. + * Use `create(RemoveCustomDomainRequestSchema)` to create a new message. + */ +export const RemoveCustomDomainRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 22); + +/** + * Describes the message tailor.v1.RemoveCustomDomainResponse. + * Use `create(RemoveCustomDomainResponseSchema)` to create a new message. + */ +export const RemoveCustomDomainResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite, 23); + diff --git a/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.d.ts b/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.d.ts index d115f7665..694aaddb2 100644 --- a/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.d.ts @@ -2,8 +2,9 @@ // @generated from file tailor/v1/staticwebsite_resource.proto (package tailor.v1, syntax proto3) /* eslint-disable */ -import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; +import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; +import type { Timestamp } from "@bufbuild/protobuf/wkt"; /** * Describes the file tailor/v1/staticwebsite_resource.proto. @@ -41,3 +42,89 @@ export declare type StaticWebsite = Message<"tailor.v1.StaticWebsite"> & { */ export declare const StaticWebsiteSchema: GenMessage; +/** + * @generated from message tailor.v1.CustomDomain + */ +export declare type CustomDomain = Message<"tailor.v1.CustomDomain"> & { + /** + * @generated from field: string domain = 1; + */ + domain: string; + + /** + * @generated from field: tailor.v1.CustomDomainStatus status = 2; + */ + status: CustomDomainStatus; + + /** + * @generated from field: string traffic_cname_target = 3; + */ + trafficCnameTarget: string; + + /** + * @generated from field: string certificate_cname_target = 4; + */ + certificateCnameTarget: string; + + /** + * @generated from field: string error_message = 5; + */ + errorMessage: string; + + /** + * @generated from field: google.protobuf.Timestamp created_at = 6; + */ + createdAt?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp updated_at = 7; + */ + updatedAt?: Timestamp; +}; + +/** + * Describes the message tailor.v1.CustomDomain. + * Use `create(CustomDomainSchema)` to create a new message. + */ +export declare const CustomDomainSchema: GenMessage; + +/** + * @generated from enum tailor.v1.CustomDomainStatus + */ +export enum CustomDomainStatus { + /** + * @generated from enum value: CUSTOM_DOMAIN_STATUS_UNSPECIFIED = 0; + */ + UNSPECIFIED = 0, + + /** + * @generated from enum value: CUSTOM_DOMAIN_STATUS_PENDING = 1; + */ + PENDING = 1, + + /** + * @generated from enum value: CUSTOM_DOMAIN_STATUS_VERIFYING = 2; + */ + VERIFYING = 2, + + /** + * @generated from enum value: CUSTOM_DOMAIN_STATUS_CERT_ISSUED = 3; + */ + CERT_ISSUED = 3, + + /** + * @generated from enum value: CUSTOM_DOMAIN_STATUS_ACTIVE = 4; + */ + ACTIVE = 4, + + /** + * @generated from enum value: CUSTOM_DOMAIN_STATUS_FAILED = 5; + */ + FAILED = 5, +} + +/** + * Describes the enum tailor.v1.CustomDomainStatus. + */ +export declare const CustomDomainStatusSchema: GenEnum; + diff --git a/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.js b/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.js index 7371a0a66..3c821d30e 100644 --- a/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.js +++ b/packages/tailor-proto/src/tailor/v1/staticwebsite_resource_pb.js @@ -2,15 +2,16 @@ // @generated from file tailor/v1/staticwebsite_resource.proto (package tailor.v1, syntax proto3) /* eslint-disable */ -import { fileDesc, messageDesc } from "@bufbuild/protobuf/codegenv2"; +import { enumDesc, fileDesc, messageDesc, tsEnum } from "@bufbuild/protobuf/codegenv2"; import { file_buf_validate_validate } from "../../buf/validate/validate_pb"; import { file_google_api_field_behavior } from "../../google/api/field_behavior_pb"; +import { file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; /** * Describes the file tailor/v1/staticwebsite_resource.proto. */ export const file_tailor_v1_staticwebsite_resource = /*@__PURE__*/ - fileDesc("CiZ0YWlsb3IvdjEvc3RhdGljd2Vic2l0ZV9yZXNvdXJjZS5wcm90bxIJdGFpbG9yLnYxIowBCg1TdGF0aWNXZWJzaXRlEjYKBG5hbWUYASABKAlCKLpIJXIjMiFeW2EtejAtOV1bYS16MC05LV17MSw2MX1bYS16MC05XSQSEwoLZGVzY3JpcHRpb24YAiABKAkSHAoUYWxsb3dlZF9pcF9hZGRyZXNzZXMYAyADKAkSEAoDdXJsGAQgASgJQgPgQQNiBnByb3RvMw", [file_buf_validate_validate, file_google_api_field_behavior]); + fileDesc("CiZ0YWlsb3IvdjEvc3RhdGljd2Vic2l0ZV9yZXNvdXJjZS5wcm90bxIJdGFpbG9yLnYxIowBCg1TdGF0aWNXZWJzaXRlEjYKBG5hbWUYASABKAlCKLpIJXIjMiFeW2EtejAtOV1bYS16MC05LV17MSw2MX1bYS16MC05XSQSEwoLZGVzY3JpcHRpb24YAiABKAkSHAoUYWxsb3dlZF9pcF9hZGRyZXNzZXMYAyADKAkSEAoDdXJsGAQgASgJQgPgQQMiogIKDEN1c3RvbURvbWFpbhIOCgZkb21haW4YASABKAkSMgoGc3RhdHVzGAIgASgOMh0udGFpbG9yLnYxLkN1c3RvbURvbWFpblN0YXR1c0ID4EEDEiEKFHRyYWZmaWNfY25hbWVfdGFyZ2V0GAMgASgJQgPgQQMSJQoYY2VydGlmaWNhdGVfY25hbWVfdGFyZ2V0GAQgASgJQgPgQQMSGgoNZXJyb3JfbWVzc2FnZRgFIAEoCUID4EEDEjMKCmNyZWF0ZWRfYXQYBiABKAsyGi5nb29nbGUucHJvdG9idWYuVGltZXN0YW1wQgPgQQMSMwoKdXBkYXRlZF9hdBgHIAEoCzIaLmdvb2dsZS5wcm90b2J1Zi5UaW1lc3RhbXBCA+BBAyroAQoSQ3VzdG9tRG9tYWluU3RhdHVzEiQKIENVU1RPTV9ET01BSU5fU1RBVFVTX1VOU1BFQ0lGSUVEEAASIAocQ1VTVE9NX0RPTUFJTl9TVEFUVVNfUEVORElORxABEiIKHkNVU1RPTV9ET01BSU5fU1RBVFVTX1ZFUklGWUlORxACEiQKIENVU1RPTV9ET01BSU5fU1RBVFVTX0NFUlRfSVNTVUVEEAMSHwobQ1VTVE9NX0RPTUFJTl9TVEFUVVNfQUNUSVZFEAQSHwobQ1VTVE9NX0RPTUFJTl9TVEFUVVNfRkFJTEVEEAViBnByb3RvMw", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_timestamp]); /** * Describes the message tailor.v1.StaticWebsite. @@ -19,3 +20,22 @@ export const file_tailor_v1_staticwebsite_resource = /*@__PURE__*/ export const StaticWebsiteSchema = /*@__PURE__*/ messageDesc(file_tailor_v1_staticwebsite_resource, 0); +/** + * Describes the message tailor.v1.CustomDomain. + * Use `create(CustomDomainSchema)` to create a new message. + */ +export const CustomDomainSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_staticwebsite_resource, 1); + +/** + * Describes the enum tailor.v1.CustomDomainStatus. + */ +export const CustomDomainStatusSchema = /*@__PURE__*/ + enumDesc(file_tailor_v1_staticwebsite_resource, 0); + +/** + * @generated from enum tailor.v1.CustomDomainStatus + */ +export const CustomDomainStatus = /*@__PURE__*/ + tsEnum(CustomDomainStatusSchema); + diff --git a/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.d.ts b/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.d.ts index 4b533d500..4524ef93a 100644 --- a/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.d.ts @@ -112,6 +112,16 @@ export declare type TailorDBType_TypeConfig = Message<"tailor.v1.TailorDBType.Ty * @generated from field: map files = 11; */ files: { [key: string]: TailorDBType_FileConfig }; + + /** + * @generated from field: optional tailor.v1.TailorDBType.TypeHook type_hook = 12; + */ + typeHook?: TailorDBType_TypeHook; + + /** + * @generated from field: optional tailor.v1.TailorDBType.TypeValidate type_validate = 13; + */ + typeValidate?: TailorDBType_TypeValidate; }; /** @@ -465,6 +475,48 @@ export declare type TailorDBType_FieldHook = Message<"tailor.v1.TailorDBType.Fie */ export declare const TailorDBType_FieldHookSchema: GenMessage; +/** + * @generated from message tailor.v1.TailorDBType.TypeHook + */ +export declare type TailorDBType_TypeHook = Message<"tailor.v1.TailorDBType.TypeHook"> & { + /** + * @generated from field: tailor.v1.Script create = 1; + */ + create?: Script; + + /** + * @generated from field: tailor.v1.Script update = 2; + */ + update?: Script; +}; + +/** + * Describes the message tailor.v1.TailorDBType.TypeHook. + * Use `create(TailorDBType_TypeHookSchema)` to create a new message. + */ +export declare const TailorDBType_TypeHookSchema: GenMessage; + +/** + * @generated from message tailor.v1.TailorDBType.TypeValidate + */ +export declare type TailorDBType_TypeValidate = Message<"tailor.v1.TailorDBType.TypeValidate"> & { + /** + * @generated from field: tailor.v1.Script create = 1; + */ + create?: Script; + + /** + * @generated from field: tailor.v1.Script update = 2; + */ + update?: Script; +}; + +/** + * Describes the message tailor.v1.TailorDBType.TypeValidate. + * Use `create(TailorDBType_TypeValidateSchema)` to create a new message. + */ +export declare const TailorDBType_TypeValidateSchema: GenMessage; + /** * @generated from message tailor.v1.TailorDBType.Serial */ diff --git a/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.js b/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.js index bef27a82e..3c87f6799 100644 --- a/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.js +++ b/packages/tailor-proto/src/tailor/v1/tailordb_resource_pb.js @@ -12,7 +12,7 @@ import { file_tailor_v1_resource } from "./resource_pb"; * Describes the file tailor/v1/tailordb_resource.proto. */ export const file_tailor_v1_tailordb_resource = /*@__PURE__*/ - fileDesc("CiF0YWlsb3IvdjEvdGFpbG9yZGJfcmVzb3VyY2UucHJvdG8SCXRhaWxvci52MSJUCg9UYWlsb3JEQlNlcnZpY2USJwoJbmFtZXNwYWNlGAEgASgLMhQudGFpbG9yLnYxLk5hbWVzcGFjZRIYChBkZWZhdWx0X3RpbWV6b25lGAIgASgJIr4nCgxUYWlsb3JEQlR5cGUSLQoEbmFtZRgBIAEoCUIfukgcchoyGF5bQS1aXVthLXpBLVowLTldezAsNjJ9JBIyCgZzY2hlbWEYAiABKAsyIi50YWlsb3IudjEuVGFpbG9yREJUeXBlLlR5cGVDb25maWca3gcKClR5cGVDb25maWcSPgoGZmllbGRzGAEgAygLMi4udGFpbG9yLnYxLlRhaWxvckRCVHlwZS5UeXBlQ29uZmlnLkZpZWxkc0VudHJ5EhMKC2Rlc2NyaXB0aW9uGAIgASgJEjUKCHNldHRpbmdzGAMgASgLMiMudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5UeXBlU2V0dGluZxI/Cg90eXBlX3Blcm1pc3Npb24YBCABKAsyJi50YWlsb3IudjEuVGFpbG9yREJUeXBlLlR5cGVQZXJtaXNzaW9uEg8KB2V4dGVuZHMYBSABKAgSNQoKZGlyZWN0aXZlcxgGIAMoCzIhLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuRGlyZWN0aXZlEkAKB2luZGV4ZXMYByADKAsyLy50YWlsb3IudjEuVGFpbG9yREJUeXBlLlR5cGVDb25maWcuSW5kZXhlc0VudHJ5EkgKEXJlY29yZF9wZXJtaXNzaW9uGAggASgLMigudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5SZWNvcmRQZXJtaXNzaW9uSACIAQESTAoNcmVsYXRpb25zaGlwcxgJIAMoCzI1LnRhaWxvci52MS5UYWlsb3JEQlR5cGUuVHlwZUNvbmZpZy5SZWxhdGlvbnNoaXBzRW50cnkSNgoKcGVybWlzc2lvbhgKIAEoCzIiLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbhI8CgVmaWxlcxgLIAMoCzItLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuVHlwZUNvbmZpZy5GaWxlc0VudHJ5GlIKC0ZpZWxkc0VudHJ5EgsKA2tleRgBIAEoCRIyCgV2YWx1ZRgCIAEoCzIjLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuRmllbGRDb25maWc6AjgBGk0KDEluZGV4ZXNFbnRyeRILCgNrZXkYASABKAkSLAoFdmFsdWUYAiABKAsyHS50YWlsb3IudjEuVGFpbG9yREJUeXBlLkluZGV4OgI4ARpgChJSZWxhdGlvbnNoaXBzRW50cnkSCwoDa2V5GAEgASgJEjkKBXZhbHVlGAIgASgLMioudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5SZWxhdGlvbnNoaXBDb25maWc6AjgBGlAKCkZpbGVzRW50cnkSCwoDa2V5GAEgASgJEjEKBXZhbHVlGAIgASgLMiIudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5GaWxlQ29uZmlnOgI4AUIUChJfcmVjb3JkX3Blcm1pc3Npb24ahwMKC1R5cGVTZXR0aW5nEhMKC2FnZ3JlZ2F0aW9uGAIgASgIEhMKC2J1bGtfdXBzZXJ0GAMgASgIEiUKGGRlZmF1bHRfcXVlcnlfbGltaXRfc2l6ZRgEIAEoA0gAiAEBEiEKFG1heF9idWxrX3Vwc2VydF9zaXplGAUgASgDSAGIAQESPAoLcGx1cmFsX2Zvcm0YBiABKAlCIrpIH3IdMhteJHxeW2Etel1bYS16QS1aMC05XXswLDYyfSRIAogBARIdChVwdWJsaXNoX3JlY29yZF9ldmVudHMYByABKAgSDQoFZHJhZnQYCCABKAgSTAoWZGlzYWJsZV9ncWxfb3BlcmF0aW9ucxgJIAEoCzIsLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuRGlzYWJsZUdxbE9wZXJhdGlvbnNCGwoZX2RlZmF1bHRfcXVlcnlfbGltaXRfc2l6ZUIXChVfbWF4X2J1bGtfdXBzZXJ0X3NpemVCDgoMX3BsdXJhbF9mb3JtSgQIARACGlQKFERpc2FibGVHcWxPcGVyYXRpb25zEg4KBmNyZWF0ZRgBIAEoCBIOCgZ1cGRhdGUYAiABKAgSDgoGZGVsZXRlGAMgASgIEgwKBHJlYWQYBCABKAgaTQoJRGlyZWN0aXZlEgwKBG5hbWUYASABKAkSMgoEYXJncxgCIAMoCzIkLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuRGlyZWN0aXZlQXJnGisKDERpcmVjdGl2ZUFyZxIMCgRuYW1lGAEgASgJEg0KBXZhbHVlGAIgASgJGiwKBUluZGV4EhMKC2ZpZWxkX25hbWVzGAEgAygJEg4KBnVuaXF1ZRgCIAEoCBrLBQoLRmllbGRDb25maWcSDAoEdHlwZRgBIAEoCRITCgtkZXNjcmlwdGlvbhgDIAEoCRIWCglzb3VyY2VfaWQYBCABKAlIAIgBARIQCghyZXF1aXJlZBgFIAEoCBINCgVhcnJheRgGIAEoCBI4Cgh2YWxpZGF0ZRgHIAMoCzImLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuVmFsaWRhdGVDb25maWcSPwoGZmllbGRzGAggAygLMi8udGFpbG9yLnYxLlRhaWxvckRCVHlwZS5GaWVsZENvbmZpZy5GaWVsZHNFbnRyeRINCgVpbmRleBgJIAEoCBIOCgZ1bmlxdWUYCiABKAgSEwoLZm9yZWlnbl9rZXkYCyABKAgSHQoQZm9yZWlnbl9rZXlfdHlwZRgMIAEoCUgBiAEBEh4KEWZvcmVpZ25fa2V5X2ZpZWxkGA0gASgJSAKIAQESNQoFaG9va3MYDiABKAsyIS50YWlsb3IudjEuVGFpbG9yREJUeXBlLkZpZWxkSG9va0gDiAEBEjUKDmFsbG93ZWRfdmFsdWVzGA8gAygLMh0udGFpbG9yLnYxLlRhaWxvckRCVHlwZS5WYWx1ZRIOCgZ2ZWN0b3IYECABKAgSLgoGc2VyaWFsGBEgASgLMh4udGFpbG9yLnYxLlRhaWxvckRCVHlwZS5TZXJpYWwSHQoFc2NhbGUYEiABKAVCCbpIBhoEGAwoAEgEiAEBGlIKC0ZpZWxkc0VudHJ5EgsKA2tleRgBIAEoCRIyCgV2YWx1ZRgCIAEoCzIjLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuRmllbGRDb25maWc6AjgBQgwKCl9zb3VyY2VfaWRCEwoRX2ZvcmVpZ25fa2V5X3R5cGVCFAoSX2ZvcmVpZ25fa2V5X2ZpZWxkQggKBl9ob29rc0IICgZfc2NhbGVKBAgCEAMacAoSUmVsYXRpb25zaGlwQ29uZmlnEhAKCHJlZl90eXBlGAEgASgJEhEKCXJlZl9maWVsZBgCIAEoCRIRCglzcmNfZmllbGQYAyABKAkSDQoFYXJyYXkYBCABKAgSEwoLZGVzY3JpcHRpb24YBSABKAkaIQoKRmlsZUNvbmZpZxITCgtkZXNjcmlwdGlvbhgBIAEoCRpjCgVWYWx1ZRJFCgV2YWx1ZRgBIAEoCUI2ukgzcjEyHF5bYS16QS1aXVthLXpBLVowLTlfXXswLDYyfSRaBHRydWVaBWZhbHNlWgRudWxsEhMKC2Rlc2NyaXB0aW9uGAIgASgJGqUBCglGaWVsZEhvb2sSGAoLY3JlYXRlX2V4cHIYASABKAlIAIgBARIYCgt1cGRhdGVfZXhwchgCIAEoCUgBiAEBEiEKBmNyZWF0ZRgDIAEoCzIRLnRhaWxvci52MS5TY3JpcHQSIQoGdXBkYXRlGAQgASgLMhEudGFpbG9yLnYxLlNjcmlwdEIOCgxfY3JlYXRlX2V4cHJCDgoMX3VwZGF0ZV9leHByGq4BCgZTZXJpYWwSFgoFc3RhcnQYASABKANCB7pIBCICIAASHwoJbWF4X3ZhbHVlGAIgASgDQge6SAQiAiAASACIAQESUgoGZm9ybWF0GAMgASgJQj26SDpyOBggMjReKD86KD86JSV8W14lXSkqKSUoPzpbMC05XSspP1tkb3hYXSg/Oig/OiUlfFteJV0pKikkSAGIAQFCDAoKX21heF92YWx1ZUIJCgdfZm9ybWF0GrEBCg5WYWxpZGF0ZUNvbmZpZxIMCgRleHByGAEgASgJEkAKBmFjdGlvbhgCIAEoDjIkLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWl0QWN0aW9uQgq6SAeCAQQQASAAEhoKDWVycm9yX21lc3NhZ2UYAyABKAlIAIgBARIhCgZzY3JpcHQYBCABKAsyES50YWlsb3IudjEuU2NyaXB0QhAKDl9lcnJvcl9tZXNzYWdlGqUCCg5UeXBlUGVybWlzc2lvbhI2CgZjcmVhdGUYASADKAsyJi50YWlsb3IudjEuVGFpbG9yREJUeXBlLlBlcm1pc3Npb25JdGVtEjQKBHJlYWQYAiADKAsyJi50YWlsb3IudjEuVGFpbG9yREJUeXBlLlBlcm1pc3Npb25JdGVtEjYKBnVwZGF0ZRgDIAMoCzImLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbkl0ZW0SNgoGZGVsZXRlGAQgAygLMiYudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5QZXJtaXNzaW9uSXRlbRI1CgVhZG1pbhgFIAMoCzImLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbkl0ZW0auAEKEFJlY29yZFBlcm1pc3Npb24SNAoEcmVhZBgBIAMoCzImLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbkl0ZW0SNgoGdXBkYXRlGAIgAygLMiYudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5QZXJtaXNzaW9uSXRlbRI2CgZkZWxldGUYAyADKAsyJi50YWlsb3IudjEuVGFpbG9yREJUeXBlLlBlcm1pc3Npb25JdGVtGmsKDlBlcm1pc3Npb25JdGVtEkAKBnBlcm1pdBgBIAEoDjIkLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWl0QWN0aW9uQgq6SAeCAQQQASAAEgoKAmlkGAIgASgJEgsKA2lkcxgDIAMoCRq+CAoKUGVybWlzc2lvbhI5CgZjcmVhdGUYASADKAsyKS50YWlsb3IudjEuVGFpbG9yREJUeXBlLlBlcm1pc3Npb24uUG9saWN5EjcKBHJlYWQYAiADKAsyKS50YWlsb3IudjEuVGFpbG9yREJUeXBlLlBlcm1pc3Npb24uUG9saWN5EjkKBnVwZGF0ZRgDIAMoCzIpLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbi5Qb2xpY3kSOQoGZGVsZXRlGAQgAygLMikudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5QZXJtaXNzaW9uLlBvbGljeRq7AQoGUG9saWN5EkAKCmNvbmRpdGlvbnMYASADKAsyLC50YWlsb3IudjEuVGFpbG9yREJUeXBlLlBlcm1pc3Npb24uQ29uZGl0aW9uEkUKBnBlcm1pdBgCIAEoDjIpLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbi5QZXJtaXRCCrpIB4IBBBABIAASGAoLZGVzY3JpcHRpb24YAyABKAlIAIgBAUIOCgxfZGVzY3JpcHRpb24a2wEKCUNvbmRpdGlvbhJACgRsZWZ0GAEgASgLMioudGFpbG9yLnYxLlRhaWxvckRCVHlwZS5QZXJtaXNzaW9uLk9wZXJhbmRCBrpIA8gBARJJCghvcGVyYXRvchgCIAEoDjIrLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbi5PcGVyYXRvckIKukgHggEEEAEgABJBCgVyaWdodBgDIAEoCzIqLnRhaWxvci52MS5UYWlsb3JEQlR5cGUuUGVybWlzc2lvbi5PcGVyYW5kQga6SAPIAQEaywEKB09wZXJhbmQSHQoKdXNlcl9maWVsZBgBIAEoCUIHukgEcgIQAUgAEh8KDHJlY29yZF9maWVsZBgCIAEoCUIHukgEcgIQAUgAEiMKEG9sZF9yZWNvcmRfZmllbGQYAyABKAlCB7pIBHICEAFIABIjChBuZXdfcmVjb3JkX2ZpZWxkGAQgASgJQge6SARyAhABSAASJwoFdmFsdWUYBSABKAsyFi5nb29nbGUucHJvdG9idWYuVmFsdWVIAEINCgRraW5kEgW6SAIIASKWAQoIT3BlcmF0b3ISGAoUT1BFUkFUT1JfVU5TUEVDSUZJRUQQABIPCgtPUEVSQVRPUl9FURABEg8KC09QRVJBVE9SX05FEAISDwoLT1BFUkFUT1JfSU4QAxIQCgxPUEVSQVRPUl9OSU4QBBIUChBPUEVSQVRPUl9IQVNfQU5ZEAUSFQoRT1BFUkFUT1JfTkhBU19BTlkQBiJDCgZQZXJtaXQSFgoSUEVSTUlUX1VOU1BFQ0lGSUVEEAASEAoMUEVSTUlUX0FMTE9XEAESDwoLUEVSTUlUX0RFTlkQAiJ6CgxQZXJtaXRBY3Rpb24SHQoZUEVSTUlUX0FDVElPTl9VTlNQRUNJRklFRBAAEhcKE1BFUk1JVF9BQ1RJT05fQUxMT1cQARIaChJQRVJNSVRfQUNUSU9OX1NLSVAQAhoCCAESFgoSUEVSTUlUX0FDVElPTl9ERU5ZEAMirQgKFVRhaWxvckRCR1FMUGVybWlzc2lvbhIPCgJpZBgBIAEoCUID4EEDEjkKCHBvbGljaWVzGAIgAygLMicudGFpbG9yLnYxLlRhaWxvckRCR1FMUGVybWlzc2lvbi5Qb2xpY3kahAIKBlBvbGljeRI+Cgpjb25kaXRpb25zGAEgAygLMioudGFpbG9yLnYxLlRhaWxvckRCR1FMUGVybWlzc2lvbi5Db25kaXRpb24SSwoHYWN0aW9ucxgCIAMoDjInLnRhaWxvci52MS5UYWlsb3JEQkdRTFBlcm1pc3Npb24uQWN0aW9uQhG6SA6SAQsIASIHggEEEAEgABJDCgZwZXJtaXQYAyABKA4yJy50YWlsb3IudjEuVGFpbG9yREJHUUxQZXJtaXNzaW9uLlBlcm1pdEIKukgHggEEEAEgABIYCgtkZXNjcmlwdGlvbhgEIAEoCUgAiAEBQg4KDF9kZXNjcmlwdGlvbhrVAQoJQ29uZGl0aW9uEj4KBGxlZnQYASABKAsyKC50YWlsb3IudjEuVGFpbG9yREJHUUxQZXJtaXNzaW9uLk9wZXJhbmRCBrpIA8gBARJHCghvcGVyYXRvchgCIAEoDjIpLnRhaWxvci52MS5UYWlsb3JEQkdRTFBlcm1pc3Npb24uT3BlcmF0b3JCCrpIB4IBBBABIAASPwoFcmlnaHQYAyABKAsyKC50YWlsb3IudjEuVGFpbG9yREJHUUxQZXJtaXNzaW9uLk9wZXJhbmRCBrpIA8gBARpgCgdPcGVyYW5kEh0KCnVzZXJfZmllbGQYASABKAlCB7pIBHICEAFIABInCgV2YWx1ZRgFIAEoCzIWLmdvb2dsZS5wcm90b2J1Zi5WYWx1ZUgAQg0KBGtpbmQSBbpIAggBIpYBCghPcGVyYXRvchIYChRPUEVSQVRPUl9VTlNQRUNJRklFRBAAEg8KC09QRVJBVE9SX0VREAESDwoLT1BFUkFUT1JfTkUQAhIPCgtPUEVSQVRPUl9JThADEhAKDE9QRVJBVE9SX05JThAEEhQKEE9QRVJBVE9SX0hBU19BTlkQBRIVChFPUEVSQVRPUl9OSEFTX0FOWRAGIqgBCgZBY3Rpb24SFgoSQUNUSU9OX1VOU1BFQ0lGSUVEEAASDgoKQUNUSU9OX0FMTBABEhEKDUFDVElPTl9DUkVBVEUQAhIPCgtBQ1RJT05fUkVBRBADEhEKDUFDVElPTl9VUERBVEUQBBIRCg1BQ1RJT05fREVMRVRFEAUSFAoQQUNUSU9OX0FHR1JFR0FURRAGEhYKEkFDVElPTl9CVUxLX1VQU0VSVBAHIkMKBlBlcm1pdBIWChJQRVJNSVRfVU5TUEVDSUZJRUQQABIQCgxQRVJNSVRfQUxMT1cQARIPCgtQRVJNSVRfREVOWRACYgZwcm90bzM", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_struct, file_tailor_v1_resource]); + fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_struct, file_tailor_v1_resource]); /** * Describes the message tailor.v1.TailorDBService. @@ -105,74 +105,88 @@ export const TailorDBType_ValueSchema = /*@__PURE__*/ export const TailorDBType_FieldHookSchema = /*@__PURE__*/ messageDesc(file_tailor_v1_tailordb_resource, 1, 10); +/** + * Describes the message tailor.v1.TailorDBType.TypeHook. + * Use `create(TailorDBType_TypeHookSchema)` to create a new message. + */ +export const TailorDBType_TypeHookSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_tailordb_resource, 1, 11); + +/** + * Describes the message tailor.v1.TailorDBType.TypeValidate. + * Use `create(TailorDBType_TypeValidateSchema)` to create a new message. + */ +export const TailorDBType_TypeValidateSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_tailordb_resource, 1, 12); + /** * Describes the message tailor.v1.TailorDBType.Serial. * Use `create(TailorDBType_SerialSchema)` to create a new message. */ export const TailorDBType_SerialSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 11); + messageDesc(file_tailor_v1_tailordb_resource, 1, 13); /** * Describes the message tailor.v1.TailorDBType.ValidateConfig. * Use `create(TailorDBType_ValidateConfigSchema)` to create a new message. */ export const TailorDBType_ValidateConfigSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 12); + messageDesc(file_tailor_v1_tailordb_resource, 1, 14); /** * Describes the message tailor.v1.TailorDBType.TypePermission. * Use `create(TailorDBType_TypePermissionSchema)` to create a new message. */ export const TailorDBType_TypePermissionSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 13); + messageDesc(file_tailor_v1_tailordb_resource, 1, 15); /** * Describes the message tailor.v1.TailorDBType.RecordPermission. * Use `create(TailorDBType_RecordPermissionSchema)` to create a new message. */ export const TailorDBType_RecordPermissionSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 14); + messageDesc(file_tailor_v1_tailordb_resource, 1, 16); /** * Describes the message tailor.v1.TailorDBType.PermissionItem. * Use `create(TailorDBType_PermissionItemSchema)` to create a new message. */ export const TailorDBType_PermissionItemSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 15); + messageDesc(file_tailor_v1_tailordb_resource, 1, 17); /** * Describes the message tailor.v1.TailorDBType.Permission. * Use `create(TailorDBType_PermissionSchema)` to create a new message. */ export const TailorDBType_PermissionSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 16); + messageDesc(file_tailor_v1_tailordb_resource, 1, 18); /** * Describes the message tailor.v1.TailorDBType.Permission.Policy. * Use `create(TailorDBType_Permission_PolicySchema)` to create a new message. */ export const TailorDBType_Permission_PolicySchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 16, 0); + messageDesc(file_tailor_v1_tailordb_resource, 1, 18, 0); /** * Describes the message tailor.v1.TailorDBType.Permission.Condition. * Use `create(TailorDBType_Permission_ConditionSchema)` to create a new message. */ export const TailorDBType_Permission_ConditionSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 16, 1); + messageDesc(file_tailor_v1_tailordb_resource, 1, 18, 1); /** * Describes the message tailor.v1.TailorDBType.Permission.Operand. * Use `create(TailorDBType_Permission_OperandSchema)` to create a new message. */ export const TailorDBType_Permission_OperandSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_tailordb_resource, 1, 16, 2); + messageDesc(file_tailor_v1_tailordb_resource, 1, 18, 2); /** * Describes the enum tailor.v1.TailorDBType.Permission.Operator. */ export const TailorDBType_Permission_OperatorSchema = /*@__PURE__*/ - enumDesc(file_tailor_v1_tailordb_resource, 1, 16, 0); + enumDesc(file_tailor_v1_tailordb_resource, 1, 18, 0); /** * @generated from enum tailor.v1.TailorDBType.Permission.Operator @@ -184,7 +198,7 @@ export const TailorDBType_Permission_Operator = /*@__PURE__*/ * Describes the enum tailor.v1.TailorDBType.Permission.Permit. */ export const TailorDBType_Permission_PermitSchema = /*@__PURE__*/ - enumDesc(file_tailor_v1_tailordb_resource, 1, 16, 1); + enumDesc(file_tailor_v1_tailordb_resource, 1, 18, 1); /** * @generated from enum tailor.v1.TailorDBType.Permission.Permit diff --git a/packages/tailor-proto/src/tailor/v1/workflow_pb.d.ts b/packages/tailor-proto/src/tailor/v1/workflow_pb.d.ts index fd10223e8..891af84df 100644 --- a/packages/tailor-proto/src/tailor/v1/workflow_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/workflow_pb.d.ts @@ -4,7 +4,7 @@ import type { GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; -import type { ConcurrencyPolicy, RetryPolicy, Workflow, WorkflowExecution, WorkflowJobFunction } from "./workflow_resource_pb"; +import type { ConcurrencyPolicy, RetryPolicy, Workflow, WorkflowExecution, WorkflowJobFunction, WorkflowJobFunctionExecutionPolicy } from "./workflow_resource_pb"; import type { Filter, PageDirection } from "./resource_pb"; import type { AuthInvoker } from "./auth_resource_pb"; @@ -708,3 +708,251 @@ export declare type TestResumeWorkflowResponse = Message<"tailor.v1.TestResumeWo */ export declare const TestResumeWorkflowResponseSchema: GenMessage; +/** + * @generated from message tailor.v1.CreateWorkflowJobFunctionExecutionPolicyRequest + */ +export declare type CreateWorkflowJobFunctionExecutionPolicyRequest = Message<"tailor.v1.CreateWorkflowJobFunctionExecutionPolicyRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string execution_policy_key = 2; + */ + executionPolicyKey: string; + + /** + * @generated from field: optional tailor.v1.ConcurrencyPolicy concurrency_policy = 3; + */ + concurrencyPolicy?: ConcurrencyPolicy; +}; + +/** + * Describes the message tailor.v1.CreateWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(CreateWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export declare const CreateWorkflowJobFunctionExecutionPolicyRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.CreateWorkflowJobFunctionExecutionPolicyResponse + */ +export declare type CreateWorkflowJobFunctionExecutionPolicyResponse = Message<"tailor.v1.CreateWorkflowJobFunctionExecutionPolicyResponse"> & { + /** + * @generated from field: tailor.v1.WorkflowJobFunctionExecutionPolicy policy = 1; + */ + policy?: WorkflowJobFunctionExecutionPolicy; +}; + +/** + * Describes the message tailor.v1.CreateWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(CreateWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export declare const CreateWorkflowJobFunctionExecutionPolicyResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyRequest + */ +export declare type UpdateWorkflowJobFunctionExecutionPolicyRequest = Message<"tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string execution_policy_key = 2; + */ + executionPolicyKey: string; + + /** + * @generated from field: optional tailor.v1.ConcurrencyPolicy concurrency_policy = 3; + */ + concurrencyPolicy?: ConcurrencyPolicy; +}; + +/** + * Describes the message tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(UpdateWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export declare const UpdateWorkflowJobFunctionExecutionPolicyRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyResponse + */ +export declare type UpdateWorkflowJobFunctionExecutionPolicyResponse = Message<"tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyResponse"> & { + /** + * @generated from field: tailor.v1.WorkflowJobFunctionExecutionPolicy policy = 1; + */ + policy?: WorkflowJobFunctionExecutionPolicy; +}; + +/** + * Describes the message tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(UpdateWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export declare const UpdateWorkflowJobFunctionExecutionPolicyResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyRequest + */ +export declare type DeleteWorkflowJobFunctionExecutionPolicyRequest = Message<"tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string id = 2; + */ + id: string; +}; + +/** + * Describes the message tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(DeleteWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export declare const DeleteWorkflowJobFunctionExecutionPolicyRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyResponse + */ +export declare type DeleteWorkflowJobFunctionExecutionPolicyResponse = Message<"tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyResponse"> & { +}; + +/** + * Describes the message tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(DeleteWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export declare const DeleteWorkflowJobFunctionExecutionPolicyResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetWorkflowJobFunctionExecutionPolicyRequest + */ +export declare type GetWorkflowJobFunctionExecutionPolicyRequest = Message<"tailor.v1.GetWorkflowJobFunctionExecutionPolicyRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string id = 2; + */ + id: string; +}; + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(GetWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export declare const GetWorkflowJobFunctionExecutionPolicyRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetWorkflowJobFunctionExecutionPolicyResponse + */ +export declare type GetWorkflowJobFunctionExecutionPolicyResponse = Message<"tailor.v1.GetWorkflowJobFunctionExecutionPolicyResponse"> & { + /** + * @generated from field: tailor.v1.WorkflowJobFunctionExecutionPolicy policy = 1; + */ + policy?: WorkflowJobFunctionExecutionPolicy; +}; + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(GetWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export declare const GetWorkflowJobFunctionExecutionPolicyResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyRequest + */ +export declare type GetWorkflowJobFunctionExecutionPolicyByKeyRequest = Message<"tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string execution_policy_key = 2; + */ + executionPolicyKey: string; +}; + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyRequest. + * Use `create(GetWorkflowJobFunctionExecutionPolicyByKeyRequestSchema)` to create a new message. + */ +export declare const GetWorkflowJobFunctionExecutionPolicyByKeyRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyResponse + */ +export declare type GetWorkflowJobFunctionExecutionPolicyByKeyResponse = Message<"tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyResponse"> & { + /** + * @generated from field: tailor.v1.WorkflowJobFunctionExecutionPolicy policy = 1; + */ + policy?: WorkflowJobFunctionExecutionPolicy; +}; + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyResponse. + * Use `create(GetWorkflowJobFunctionExecutionPolicyByKeyResponseSchema)` to create a new message. + */ +export declare const GetWorkflowJobFunctionExecutionPolicyByKeyResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.ListWorkflowJobFunctionExecutionPoliciesRequest + */ +export declare type ListWorkflowJobFunctionExecutionPoliciesRequest = Message<"tailor.v1.ListWorkflowJobFunctionExecutionPoliciesRequest"> & { + /** + * @generated from field: string workspace_id = 1; + */ + workspaceId: string; + + /** + * @generated from field: string page_token = 2; + */ + pageToken: string; + + /** + * @generated from field: uint32 page_size = 3; + */ + pageSize: number; + + /** + * @generated from field: tailor.v1.PageDirection page_direction = 4; + */ + pageDirection: PageDirection; +}; + +/** + * Describes the message tailor.v1.ListWorkflowJobFunctionExecutionPoliciesRequest. + * Use `create(ListWorkflowJobFunctionExecutionPoliciesRequestSchema)` to create a new message. + */ +export declare const ListWorkflowJobFunctionExecutionPoliciesRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.ListWorkflowJobFunctionExecutionPoliciesResponse + */ +export declare type ListWorkflowJobFunctionExecutionPoliciesResponse = Message<"tailor.v1.ListWorkflowJobFunctionExecutionPoliciesResponse"> & { + /** + * @generated from field: repeated tailor.v1.WorkflowJobFunctionExecutionPolicy policies = 1; + */ + policies: WorkflowJobFunctionExecutionPolicy[]; + + /** + * @generated from field: string next_page_token = 2; + */ + nextPageToken: string; + + /** + * @generated from field: int64 total_count = 3; + */ + totalCount: bigint; +}; + +/** + * Describes the message tailor.v1.ListWorkflowJobFunctionExecutionPoliciesResponse. + * Use `create(ListWorkflowJobFunctionExecutionPoliciesResponseSchema)` to create a new message. + */ +export declare const ListWorkflowJobFunctionExecutionPoliciesResponseSchema: GenMessage; + diff --git a/packages/tailor-proto/src/tailor/v1/workflow_pb.js b/packages/tailor-proto/src/tailor/v1/workflow_pb.js index 9ab4e037b..872e79404 100644 --- a/packages/tailor-proto/src/tailor/v1/workflow_pb.js +++ b/packages/tailor-proto/src/tailor/v1/workflow_pb.js @@ -12,7 +12,7 @@ import { file_tailor_v1_workflow_resource } from "./workflow_resource_pb"; * Describes the file tailor/v1/workflow.proto. */ export const file_tailor_v1_workflow = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_tailor_v1_auth_resource, file_tailor_v1_resource, file_tailor_v1_workflow_resource]); + fileDesc("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", [file_buf_validate_validate, file_tailor_v1_auth_resource, file_tailor_v1_resource, file_tailor_v1_workflow_resource]); /** * Describes the message tailor.v1.CreateWorkflowRequest. @@ -224,3 +224,87 @@ export const TestResumeWorkflowRequestSchema = /*@__PURE__*/ export const TestResumeWorkflowResponseSchema = /*@__PURE__*/ messageDesc(file_tailor_v1_workflow, 29); +/** + * Describes the message tailor.v1.CreateWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(CreateWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export const CreateWorkflowJobFunctionExecutionPolicyRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 30); + +/** + * Describes the message tailor.v1.CreateWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(CreateWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export const CreateWorkflowJobFunctionExecutionPolicyResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 31); + +/** + * Describes the message tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(UpdateWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export const UpdateWorkflowJobFunctionExecutionPolicyRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 32); + +/** + * Describes the message tailor.v1.UpdateWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(UpdateWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export const UpdateWorkflowJobFunctionExecutionPolicyResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 33); + +/** + * Describes the message tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(DeleteWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export const DeleteWorkflowJobFunctionExecutionPolicyRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 34); + +/** + * Describes the message tailor.v1.DeleteWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(DeleteWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export const DeleteWorkflowJobFunctionExecutionPolicyResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 35); + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyRequest. + * Use `create(GetWorkflowJobFunctionExecutionPolicyRequestSchema)` to create a new message. + */ +export const GetWorkflowJobFunctionExecutionPolicyRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 36); + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyResponse. + * Use `create(GetWorkflowJobFunctionExecutionPolicyResponseSchema)` to create a new message. + */ +export const GetWorkflowJobFunctionExecutionPolicyResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 37); + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyRequest. + * Use `create(GetWorkflowJobFunctionExecutionPolicyByKeyRequestSchema)` to create a new message. + */ +export const GetWorkflowJobFunctionExecutionPolicyByKeyRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 38); + +/** + * Describes the message tailor.v1.GetWorkflowJobFunctionExecutionPolicyByKeyResponse. + * Use `create(GetWorkflowJobFunctionExecutionPolicyByKeyResponseSchema)` to create a new message. + */ +export const GetWorkflowJobFunctionExecutionPolicyByKeyResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 39); + +/** + * Describes the message tailor.v1.ListWorkflowJobFunctionExecutionPoliciesRequest. + * Use `create(ListWorkflowJobFunctionExecutionPoliciesRequestSchema)` to create a new message. + */ +export const ListWorkflowJobFunctionExecutionPoliciesRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 40); + +/** + * Describes the message tailor.v1.ListWorkflowJobFunctionExecutionPoliciesResponse. + * Use `create(ListWorkflowJobFunctionExecutionPoliciesResponseSchema)` to create a new message. + */ +export const ListWorkflowJobFunctionExecutionPoliciesResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow, 41); + diff --git a/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.d.ts b/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.d.ts index 1109f333d..950fb490b 100644 --- a/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.d.ts @@ -154,6 +154,50 @@ export declare type Workflow = Message<"tailor.v1.Workflow"> & { */ export declare const WorkflowSchema: GenMessage; +/** + * WorkflowJobFunctionExecutionPolicy defines a runtime concurrency limit shared by + * any job function invocation that specifies a matching execution_policy_key in + * triggerJobFunction(). The same key can be referenced by multiple job functions + * across different workflows; they all share the same concurrency pool within the workspace. + * + * @generated from message tailor.v1.WorkflowJobFunctionExecutionPolicy + */ +export declare type WorkflowJobFunctionExecutionPolicy = Message<"tailor.v1.WorkflowJobFunctionExecutionPolicy"> & { + /** + * @generated from field: string id = 1; + */ + id: string; + + /** + * @generated from field: string execution_policy_key = 2; + */ + executionPolicyKey: string; + + /** + * @generated from field: google.protobuf.Timestamp created_at = 3; + */ + createdAt?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp updated_at = 4; + */ + updatedAt?: Timestamp; + + /** + * When unset, the policy registers the key as valid but applies no user-defined + * concurrency limit (platform hard limits still apply). + * + * @generated from field: optional tailor.v1.ConcurrencyPolicy concurrency_policy = 5; + */ + concurrencyPolicy?: ConcurrencyPolicy; +}; + +/** + * Describes the message tailor.v1.WorkflowJobFunctionExecutionPolicy. + * Use `create(WorkflowJobFunctionExecutionPolicySchema)` to create a new message. + */ +export declare const WorkflowJobFunctionExecutionPolicySchema: GenMessage; + /** * @generated from message tailor.v1.WorkflowJobExecution */ diff --git a/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.js b/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.js index 323423903..5e757a67d 100644 --- a/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.js +++ b/packages/tailor-proto/src/tailor/v1/workflow_resource_pb.js @@ -11,7 +11,7 @@ import { file_google_protobuf_duration, file_google_protobuf_timestamp } from "@ * Describes the file tailor/v1/workflow_resource.proto. */ export const file_tailor_v1_workflow_resource = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_duration, file_google_protobuf_timestamp]); + fileDesc("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", [file_buf_validate_validate, file_google_api_field_behavior, file_google_protobuf_duration, file_google_protobuf_timestamp]); /** * Describes the message tailor.v1.WorkflowJobFunction. @@ -41,18 +41,25 @@ export const RetryPolicySchema = /*@__PURE__*/ export const WorkflowSchema = /*@__PURE__*/ messageDesc(file_tailor_v1_workflow_resource, 3); +/** + * Describes the message tailor.v1.WorkflowJobFunctionExecutionPolicy. + * Use `create(WorkflowJobFunctionExecutionPolicySchema)` to create a new message. + */ +export const WorkflowJobFunctionExecutionPolicySchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workflow_resource, 4); + /** * Describes the message tailor.v1.WorkflowJobExecution. * Use `create(WorkflowJobExecutionSchema)` to create a new message. */ export const WorkflowJobExecutionSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workflow_resource, 4); + messageDesc(file_tailor_v1_workflow_resource, 5); /** * Describes the enum tailor.v1.WorkflowJobExecution.Status. */ export const WorkflowJobExecution_StatusSchema = /*@__PURE__*/ - enumDesc(file_tailor_v1_workflow_resource, 4, 0); + enumDesc(file_tailor_v1_workflow_resource, 5, 0); /** * @generated from enum tailor.v1.WorkflowJobExecution.Status @@ -65,13 +72,13 @@ export const WorkflowJobExecution_Status = /*@__PURE__*/ * Use `create(WorkflowExecutionSchema)` to create a new message. */ export const WorkflowExecutionSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workflow_resource, 5); + messageDesc(file_tailor_v1_workflow_resource, 6); /** * Describes the enum tailor.v1.WorkflowExecution.Status. */ export const WorkflowExecution_StatusSchema = /*@__PURE__*/ - enumDesc(file_tailor_v1_workflow_resource, 5, 0); + enumDesc(file_tailor_v1_workflow_resource, 6, 0); /** * @generated from enum tailor.v1.WorkflowExecution.Status diff --git a/packages/tailor-proto/src/tailor/v1/workspace_pb.d.ts b/packages/tailor-proto/src/tailor/v1/workspace_pb.d.ts index 99e3358d6..6bd148f55 100644 --- a/packages/tailor-proto/src/tailor/v1/workspace_pb.d.ts +++ b/packages/tailor-proto/src/tailor/v1/workspace_pb.d.ts @@ -5,7 +5,7 @@ import type { GenEnum, GenFile, GenMessage } from "@bufbuild/protobuf/codegenv2"; import type { Message } from "@bufbuild/protobuf"; import type { Folder, FolderAccess, FolderRole, Organization, OrganizationAccess, OrganizationRole, PlatformAccountPlan, Team, TeamMember, TeamRole, Workspace, WorkspacePlatformUser, WorkspacePlatformUserRole } from "./workspace_resource_pb"; -import type { FieldMask } from "@bufbuild/protobuf/wkt"; +import type { FieldMask, Timestamp } from "@bufbuild/protobuf/wkt"; import type { PageDirection } from "./resource_pb"; /** @@ -1621,6 +1621,290 @@ export declare type GetOrganizationFolderAccessResponse = Message<"tailor.v1.Get */ export declare const GetOrganizationFolderAccessResponseSchema: GenMessage; +/** + * @generated from message tailor.v1.OrganizationIPRestriction + */ +export declare type OrganizationIPRestriction = Message<"tailor.v1.OrganizationIPRestriction"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; + + /** + * @generated from field: repeated string allowed_ip_addresses = 2; + */ + allowedIpAddresses: string[]; + + /** + * @generated from field: google.protobuf.Timestamp created_at = 3; + */ + createdAt?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp updated_at = 4; + */ + updatedAt?: Timestamp; +}; + +/** + * Describes the message tailor.v1.OrganizationIPRestriction. + * Use `create(OrganizationIPRestrictionSchema)` to create a new message. + */ +export declare const OrganizationIPRestrictionSchema: GenMessage; + +/** + * @generated from message tailor.v1.OrganizationFolderIPRestriction + */ +export declare type OrganizationFolderIPRestriction = Message<"tailor.v1.OrganizationFolderIPRestriction"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; + + /** + * @generated from field: string folder_id = 2; + */ + folderId: string; + + /** + * @generated from field: repeated string allowed_ip_addresses = 3; + */ + allowedIpAddresses: string[]; + + /** + * @generated from field: google.protobuf.Timestamp created_at = 4; + */ + createdAt?: Timestamp; + + /** + * @generated from field: google.protobuf.Timestamp updated_at = 5; + */ + updatedAt?: Timestamp; +}; + +/** + * Describes the message tailor.v1.OrganizationFolderIPRestriction. + * Use `create(OrganizationFolderIPRestrictionSchema)` to create a new message. + */ +export declare const OrganizationFolderIPRestrictionSchema: GenMessage; + +/** + * @generated from message tailor.v1.UpsertOrganizationIPRestrictionRequest + */ +export declare type UpsertOrganizationIPRestrictionRequest = Message<"tailor.v1.UpsertOrganizationIPRestrictionRequest"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; + + /** + * Must contain at least one entry. To remove the restriction entirely, call + * DeleteOrganizationIPRestriction — an empty list here is rejected so that + * "rule exists" and "non-empty allowlist" stay equivalent and Get's NotFound + * contract is unambiguous. + * + * @generated from field: repeated string allowed_ip_addresses = 2; + */ + allowedIpAddresses: string[]; +}; + +/** + * Describes the message tailor.v1.UpsertOrganizationIPRestrictionRequest. + * Use `create(UpsertOrganizationIPRestrictionRequestSchema)` to create a new message. + */ +export declare const UpsertOrganizationIPRestrictionRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.UpsertOrganizationIPRestrictionResponse + */ +export declare type UpsertOrganizationIPRestrictionResponse = Message<"tailor.v1.UpsertOrganizationIPRestrictionResponse"> & { + /** + * @generated from field: tailor.v1.OrganizationIPRestriction organization_ip_restriction = 1; + */ + organizationIpRestriction?: OrganizationIPRestriction; +}; + +/** + * Describes the message tailor.v1.UpsertOrganizationIPRestrictionResponse. + * Use `create(UpsertOrganizationIPRestrictionResponseSchema)` to create a new message. + */ +export declare const UpsertOrganizationIPRestrictionResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetOrganizationIPRestrictionRequest + */ +export declare type GetOrganizationIPRestrictionRequest = Message<"tailor.v1.GetOrganizationIPRestrictionRequest"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; +}; + +/** + * Describes the message tailor.v1.GetOrganizationIPRestrictionRequest. + * Use `create(GetOrganizationIPRestrictionRequestSchema)` to create a new message. + */ +export declare const GetOrganizationIPRestrictionRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetOrganizationIPRestrictionResponse + */ +export declare type GetOrganizationIPRestrictionResponse = Message<"tailor.v1.GetOrganizationIPRestrictionResponse"> & { + /** + * @generated from field: tailor.v1.OrganizationIPRestriction organization_ip_restriction = 1; + */ + organizationIpRestriction?: OrganizationIPRestriction; +}; + +/** + * Describes the message tailor.v1.GetOrganizationIPRestrictionResponse. + * Use `create(GetOrganizationIPRestrictionResponseSchema)` to create a new message. + */ +export declare const GetOrganizationIPRestrictionResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.DeleteOrganizationIPRestrictionRequest + */ +export declare type DeleteOrganizationIPRestrictionRequest = Message<"tailor.v1.DeleteOrganizationIPRestrictionRequest"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; +}; + +/** + * Describes the message tailor.v1.DeleteOrganizationIPRestrictionRequest. + * Use `create(DeleteOrganizationIPRestrictionRequestSchema)` to create a new message. + */ +export declare const DeleteOrganizationIPRestrictionRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.DeleteOrganizationIPRestrictionResponse + */ +export declare type DeleteOrganizationIPRestrictionResponse = Message<"tailor.v1.DeleteOrganizationIPRestrictionResponse"> & { +}; + +/** + * Describes the message tailor.v1.DeleteOrganizationIPRestrictionResponse. + * Use `create(DeleteOrganizationIPRestrictionResponseSchema)` to create a new message. + */ +export declare const DeleteOrganizationIPRestrictionResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.UpsertOrganizationFolderIPRestrictionRequest + */ +export declare type UpsertOrganizationFolderIPRestrictionRequest = Message<"tailor.v1.UpsertOrganizationFolderIPRestrictionRequest"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; + + /** + * @generated from field: string folder_id = 2; + */ + folderId: string; + + /** + * Must contain at least one entry; see UpsertOrganizationIPRestrictionRequest + * for rationale. Use DeleteOrganizationFolderIPRestriction to clear the rule. + * + * @generated from field: repeated string allowed_ip_addresses = 3; + */ + allowedIpAddresses: string[]; +}; + +/** + * Describes the message tailor.v1.UpsertOrganizationFolderIPRestrictionRequest. + * Use `create(UpsertOrganizationFolderIPRestrictionRequestSchema)` to create a new message. + */ +export declare const UpsertOrganizationFolderIPRestrictionRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.UpsertOrganizationFolderIPRestrictionResponse + */ +export declare type UpsertOrganizationFolderIPRestrictionResponse = Message<"tailor.v1.UpsertOrganizationFolderIPRestrictionResponse"> & { + /** + * @generated from field: tailor.v1.OrganizationFolderIPRestriction organization_folder_ip_restriction = 1; + */ + organizationFolderIpRestriction?: OrganizationFolderIPRestriction; +}; + +/** + * Describes the message tailor.v1.UpsertOrganizationFolderIPRestrictionResponse. + * Use `create(UpsertOrganizationFolderIPRestrictionResponseSchema)` to create a new message. + */ +export declare const UpsertOrganizationFolderIPRestrictionResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetOrganizationFolderIPRestrictionRequest + */ +export declare type GetOrganizationFolderIPRestrictionRequest = Message<"tailor.v1.GetOrganizationFolderIPRestrictionRequest"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; + + /** + * @generated from field: string folder_id = 2; + */ + folderId: string; +}; + +/** + * Describes the message tailor.v1.GetOrganizationFolderIPRestrictionRequest. + * Use `create(GetOrganizationFolderIPRestrictionRequestSchema)` to create a new message. + */ +export declare const GetOrganizationFolderIPRestrictionRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.GetOrganizationFolderIPRestrictionResponse + */ +export declare type GetOrganizationFolderIPRestrictionResponse = Message<"tailor.v1.GetOrganizationFolderIPRestrictionResponse"> & { + /** + * @generated from field: tailor.v1.OrganizationFolderIPRestriction organization_folder_ip_restriction = 1; + */ + organizationFolderIpRestriction?: OrganizationFolderIPRestriction; +}; + +/** + * Describes the message tailor.v1.GetOrganizationFolderIPRestrictionResponse. + * Use `create(GetOrganizationFolderIPRestrictionResponseSchema)` to create a new message. + */ +export declare const GetOrganizationFolderIPRestrictionResponseSchema: GenMessage; + +/** + * @generated from message tailor.v1.DeleteOrganizationFolderIPRestrictionRequest + */ +export declare type DeleteOrganizationFolderIPRestrictionRequest = Message<"tailor.v1.DeleteOrganizationFolderIPRestrictionRequest"> & { + /** + * @generated from field: string organization_id = 1; + */ + organizationId: string; + + /** + * @generated from field: string folder_id = 2; + */ + folderId: string; +}; + +/** + * Describes the message tailor.v1.DeleteOrganizationFolderIPRestrictionRequest. + * Use `create(DeleteOrganizationFolderIPRestrictionRequestSchema)` to create a new message. + */ +export declare const DeleteOrganizationFolderIPRestrictionRequestSchema: GenMessage; + +/** + * @generated from message tailor.v1.DeleteOrganizationFolderIPRestrictionResponse + */ +export declare type DeleteOrganizationFolderIPRestrictionResponse = Message<"tailor.v1.DeleteOrganizationFolderIPRestrictionResponse"> & { +}; + +/** + * Describes the message tailor.v1.DeleteOrganizationFolderIPRestrictionResponse. + * Use `create(DeleteOrganizationFolderIPRestrictionResponseSchema)` to create a new message. + */ +export declare const DeleteOrganizationFolderIPRestrictionResponseSchema: GenMessage; + /** * @generated from message tailor.v1.CreateOrganizationTeamRequest */ diff --git a/packages/tailor-proto/src/tailor/v1/workspace_pb.js b/packages/tailor-proto/src/tailor/v1/workspace_pb.js index 38cf209f3..815c25ad3 100644 --- a/packages/tailor-proto/src/tailor/v1/workspace_pb.js +++ b/packages/tailor-proto/src/tailor/v1/workspace_pb.js @@ -4,7 +4,7 @@ import { enumDesc, fileDesc, messageDesc, tsEnum } from "@bufbuild/protobuf/codegenv2"; import { file_buf_validate_validate } from "../../buf/validate/validate_pb"; -import { file_google_protobuf_field_mask } from "@bufbuild/protobuf/wkt"; +import { file_google_protobuf_field_mask, file_google_protobuf_timestamp } from "@bufbuild/protobuf/wkt"; import { file_tailor_fieldmask_v1_option } from "../fieldmask/v1/option_pb"; import { file_tailor_v1_resource } from "./resource_pb"; import { file_tailor_v1_workspace_resource } from "./workspace_resource_pb"; @@ -13,7 +13,7 @@ import { file_tailor_v1_workspace_resource } from "./workspace_resource_pb"; * Describes the file tailor/v1/workspace.proto. */ export const file_tailor_v1_workspace = /*@__PURE__*/ - fileDesc("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", [file_buf_validate_validate, file_google_protobuf_field_mask, file_tailor_fieldmask_v1_option, file_tailor_v1_resource, file_tailor_v1_workspace_resource]); + fileDesc("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", [file_buf_validate_validate, file_google_protobuf_field_mask, file_google_protobuf_timestamp, file_tailor_fieldmask_v1_option, file_tailor_v1_resource, file_tailor_v1_workspace_resource]); /** * Describes the message tailor.v1.ListAvailableWorkspaceRegionsRequest. @@ -510,157 +510,255 @@ export const GetOrganizationFolderAccessRequestSchema = /*@__PURE__*/ export const GetOrganizationFolderAccessResponseSchema = /*@__PURE__*/ messageDesc(file_tailor_v1_workspace, 67); +/** + * Describes the message tailor.v1.OrganizationIPRestriction. + * Use `create(OrganizationIPRestrictionSchema)` to create a new message. + */ +export const OrganizationIPRestrictionSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 68); + +/** + * Describes the message tailor.v1.OrganizationFolderIPRestriction. + * Use `create(OrganizationFolderIPRestrictionSchema)` to create a new message. + */ +export const OrganizationFolderIPRestrictionSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 69); + +/** + * Describes the message tailor.v1.UpsertOrganizationIPRestrictionRequest. + * Use `create(UpsertOrganizationIPRestrictionRequestSchema)` to create a new message. + */ +export const UpsertOrganizationIPRestrictionRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 70); + +/** + * Describes the message tailor.v1.UpsertOrganizationIPRestrictionResponse. + * Use `create(UpsertOrganizationIPRestrictionResponseSchema)` to create a new message. + */ +export const UpsertOrganizationIPRestrictionResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 71); + +/** + * Describes the message tailor.v1.GetOrganizationIPRestrictionRequest. + * Use `create(GetOrganizationIPRestrictionRequestSchema)` to create a new message. + */ +export const GetOrganizationIPRestrictionRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 72); + +/** + * Describes the message tailor.v1.GetOrganizationIPRestrictionResponse. + * Use `create(GetOrganizationIPRestrictionResponseSchema)` to create a new message. + */ +export const GetOrganizationIPRestrictionResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 73); + +/** + * Describes the message tailor.v1.DeleteOrganizationIPRestrictionRequest. + * Use `create(DeleteOrganizationIPRestrictionRequestSchema)` to create a new message. + */ +export const DeleteOrganizationIPRestrictionRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 74); + +/** + * Describes the message tailor.v1.DeleteOrganizationIPRestrictionResponse. + * Use `create(DeleteOrganizationIPRestrictionResponseSchema)` to create a new message. + */ +export const DeleteOrganizationIPRestrictionResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 75); + +/** + * Describes the message tailor.v1.UpsertOrganizationFolderIPRestrictionRequest. + * Use `create(UpsertOrganizationFolderIPRestrictionRequestSchema)` to create a new message. + */ +export const UpsertOrganizationFolderIPRestrictionRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 76); + +/** + * Describes the message tailor.v1.UpsertOrganizationFolderIPRestrictionResponse. + * Use `create(UpsertOrganizationFolderIPRestrictionResponseSchema)` to create a new message. + */ +export const UpsertOrganizationFolderIPRestrictionResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 77); + +/** + * Describes the message tailor.v1.GetOrganizationFolderIPRestrictionRequest. + * Use `create(GetOrganizationFolderIPRestrictionRequestSchema)` to create a new message. + */ +export const GetOrganizationFolderIPRestrictionRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 78); + +/** + * Describes the message tailor.v1.GetOrganizationFolderIPRestrictionResponse. + * Use `create(GetOrganizationFolderIPRestrictionResponseSchema)` to create a new message. + */ +export const GetOrganizationFolderIPRestrictionResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 79); + +/** + * Describes the message tailor.v1.DeleteOrganizationFolderIPRestrictionRequest. + * Use `create(DeleteOrganizationFolderIPRestrictionRequestSchema)` to create a new message. + */ +export const DeleteOrganizationFolderIPRestrictionRequestSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 80); + +/** + * Describes the message tailor.v1.DeleteOrganizationFolderIPRestrictionResponse. + * Use `create(DeleteOrganizationFolderIPRestrictionResponseSchema)` to create a new message. + */ +export const DeleteOrganizationFolderIPRestrictionResponseSchema = /*@__PURE__*/ + messageDesc(file_tailor_v1_workspace, 81); + /** * Describes the message tailor.v1.CreateOrganizationTeamRequest. * Use `create(CreateOrganizationTeamRequestSchema)` to create a new message. */ export const CreateOrganizationTeamRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 68); + messageDesc(file_tailor_v1_workspace, 82); /** * Describes the message tailor.v1.CreateOrganizationTeamResponse. * Use `create(CreateOrganizationTeamResponseSchema)` to create a new message. */ export const CreateOrganizationTeamResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 69); + messageDesc(file_tailor_v1_workspace, 83); /** * Describes the message tailor.v1.UpdateOrganizationTeamRequest. * Use `create(UpdateOrganizationTeamRequestSchema)` to create a new message. */ export const UpdateOrganizationTeamRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 70); + messageDesc(file_tailor_v1_workspace, 84); /** * Describes the message tailor.v1.UpdateOrganizationTeamResponse. * Use `create(UpdateOrganizationTeamResponseSchema)` to create a new message. */ export const UpdateOrganizationTeamResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 71); + messageDesc(file_tailor_v1_workspace, 85); /** * Describes the message tailor.v1.DeleteOrganizationTeamRequest. * Use `create(DeleteOrganizationTeamRequestSchema)` to create a new message. */ export const DeleteOrganizationTeamRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 72); + messageDesc(file_tailor_v1_workspace, 86); /** * Describes the message tailor.v1.DeleteOrganizationTeamResponse. * Use `create(DeleteOrganizationTeamResponseSchema)` to create a new message. */ export const DeleteOrganizationTeamResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 73); + messageDesc(file_tailor_v1_workspace, 87); /** * Describes the message tailor.v1.ListOrganizationTeamsRequest. * Use `create(ListOrganizationTeamsRequestSchema)` to create a new message. */ export const ListOrganizationTeamsRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 74); + messageDesc(file_tailor_v1_workspace, 88); /** * Describes the message tailor.v1.ListOrganizationTeamsResponse. * Use `create(ListOrganizationTeamsResponseSchema)` to create a new message. */ export const ListOrganizationTeamsResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 75); + messageDesc(file_tailor_v1_workspace, 89); /** * Describes the message tailor.v1.GetOrganizationTeamRequest. * Use `create(GetOrganizationTeamRequestSchema)` to create a new message. */ export const GetOrganizationTeamRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 76); + messageDesc(file_tailor_v1_workspace, 90); /** * Describes the message tailor.v1.GetOrganizationTeamResponse. * Use `create(GetOrganizationTeamResponseSchema)` to create a new message. */ export const GetOrganizationTeamResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 77); + messageDesc(file_tailor_v1_workspace, 91); /** * Describes the message tailor.v1.AddOrganizationTeamMemberRequest. * Use `create(AddOrganizationTeamMemberRequestSchema)` to create a new message. */ export const AddOrganizationTeamMemberRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 78); + messageDesc(file_tailor_v1_workspace, 92); /** * Describes the message tailor.v1.AddOrganizationTeamMemberResponse. * Use `create(AddOrganizationTeamMemberResponseSchema)` to create a new message. */ export const AddOrganizationTeamMemberResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 79); + messageDesc(file_tailor_v1_workspace, 93); /** * Describes the message tailor.v1.UpdateOrganizationTeamMemberRequest. * Use `create(UpdateOrganizationTeamMemberRequestSchema)` to create a new message. */ export const UpdateOrganizationTeamMemberRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 80); + messageDesc(file_tailor_v1_workspace, 94); /** * Describes the message tailor.v1.UpdateOrganizationTeamMemberResponse. * Use `create(UpdateOrganizationTeamMemberResponseSchema)` to create a new message. */ export const UpdateOrganizationTeamMemberResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 81); + messageDesc(file_tailor_v1_workspace, 95); /** * Describes the message tailor.v1.RemoveOrganizationTeamMemberRequest. * Use `create(RemoveOrganizationTeamMemberRequestSchema)` to create a new message. */ export const RemoveOrganizationTeamMemberRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 82); + messageDesc(file_tailor_v1_workspace, 96); /** * Describes the message tailor.v1.RemoveOrganizationTeamMemberResponse. * Use `create(RemoveOrganizationTeamMemberResponseSchema)` to create a new message. */ export const RemoveOrganizationTeamMemberResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 83); + messageDesc(file_tailor_v1_workspace, 97); /** * Describes the message tailor.v1.ListOrganizationTeamMembersRequest. * Use `create(ListOrganizationTeamMembersRequestSchema)` to create a new message. */ export const ListOrganizationTeamMembersRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 84); + messageDesc(file_tailor_v1_workspace, 98); /** * Describes the message tailor.v1.ListOrganizationTeamMembersResponse. * Use `create(ListOrganizationTeamMembersResponseSchema)` to create a new message. */ export const ListOrganizationTeamMembersResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 85); + messageDesc(file_tailor_v1_workspace, 99); /** * Describes the message tailor.v1.GetOrganizationTeamMemberRequest. * Use `create(GetOrganizationTeamMemberRequestSchema)` to create a new message. */ export const GetOrganizationTeamMemberRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 86); + messageDesc(file_tailor_v1_workspace, 100); /** * Describes the message tailor.v1.GetOrganizationTeamMemberResponse. * Use `create(GetOrganizationTeamMemberResponseSchema)` to create a new message. */ export const GetOrganizationTeamMemberResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 87); + messageDesc(file_tailor_v1_workspace, 101); /** * Describes the message tailor.v1.GetPlatformAccountPlanRequest. * Use `create(GetPlatformAccountPlanRequestSchema)` to create a new message. */ export const GetPlatformAccountPlanRequestSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 88); + messageDesc(file_tailor_v1_workspace, 102); /** * Describes the message tailor.v1.GetPlatformAccountPlanResponse. * Use `create(GetPlatformAccountPlanResponseSchema)` to create a new message. */ export const GetPlatformAccountPlanResponseSchema = /*@__PURE__*/ - messageDesc(file_tailor_v1_workspace, 89); + messageDesc(file_tailor_v1_workspace, 103);