Open source website builder and Webflow alternative. Webstudio is an advanced visual builder that connects to any headless CMS, supports all CSS properties, and can be hosted anywhere, including with us.
TypeScript accessibilityalternativecloudflarecloudflare-workersdesignfreefrontendopen-sourceradix-uireactremixweb-developmentwebflowwebsite-builderwebsite-developmentwebsiteswebstudio
import type { BuilderState } from "../state/builder-state";
import {
builderNamespaces,
type BuilderNamespace,
} from "../contracts/namespaces";
import type { BuilderApiCapability } from "../contracts/permissions";
import { outputDetailInputSchema, paginatedOutputInputSchema } from "./output";
import {
getInputSchemaMetadata,
isHiddenPublicApiInputField,
} from "../contracts/input-schema";
import {
assetType,
contentBlockSource as contentBlockSourceSchema,
instanceFilterInput,
type InputJsonSchema,
} from "@webstudio-is/sdk";
import { pageCopyNamespaces } from "../contracts/namespaces";
import { builderRuntimeContext, type BuilderRuntimeContext } from "./context";
import { z } from "zod";
import { isMdxTemplateComponentName } from "@webstudio-is/content-engine/mdx";
import * as assets from "./assets";
import * as assetResources from "./asset-resources";
import * as bindingVerification from "./binding-verification";
import * as assetFolders from "./asset-folders";
import * as components from "./components";
import * as collection from "./collection";
import * as data from "./data";
import * as fonts from "./fonts";
import * as instanceDuplicate from "./instance-duplicate";
import * as instances from "./instances";
import * as migrations from "./migrations";
import * as mdxPaste from "./mdx-paste";
import { mdxTemplateMigrationFileLimit } from "./mdx-template-migration";
import * as pageCopy from "./page-copy";
import * as pages from "./pages";
import * as projectSettings from "./project-settings";
import * as props from "./props";
import * as runtimeUi from "./runtime-ui";
import * as projectSearch from "./project-search";
import * as slot from "./slot";
import * as designTokenImport from "./design-token-import";
import * as audit from "./audit";
import * as styles from "./styles";
import {
getZodValidationIssues,
throwBuilderRuntimeError,
throwBuilderValidationError,
} from "./errors";
import {
createRuntimeMutationExecutionSchema,
getRuntimeOutputSchema,
type RuntimeOperationOutput,
type RuntimeOutputSchemaId,
} from "./output-schemas";
import { createRuntimeMutation, type BuilderRuntimeMutation } from "./mutation";
import { mutationPolicies } from "./mutation-policies";
import { listFragmentExpressions } from "./fragment";
import {
bindExpressionInput,
getScopedExpressionWarnings,
} from "./expression-scope";
export type BuilderRuntimeOperation<
Id extends string = string,
Input = unknown,
Result = unknown,
> = {
id: Id;
command: string;
client: string;
permit?: BuilderApiCapability;
kind: "read" | "mutation";
inputSchema: z.ZodTypeAny;
inputJsonSchema: InputJsonSchema;
outputSchema: z.ZodTypeAny;
outputJsonSchema: InputJsonSchema;
readNamespaces: readonly BuilderNamespace[];
writeNamespaces: readonly BuilderNamespace[];
invalidatesNamespaces: readonly BuilderNamespace[];
retryOnConflict: boolean;
requiresAssets: boolean;
requiresConfirm: boolean;
execute: (args: {
state: BuilderState;
input: unknown;
context: BuilderRuntimeContext;
}) => Result | Promise<Result>;
readonly __input?: Input;
readonly __result?: Result;
};
type RuntimeOperationPublicApi = {
command: string;
client: string;
permit?: BuilderApiCapability;
};
type RuntimeOperationContractInput =
| {
kind: "read";
readNamespaces: readonly BuilderNamespace[];
requiresAssets?: boolean;
}
| {
kind: "mutation";
readNamespaces: readonly BuilderNamespace[];
writeNamespaces: readonly BuilderNamespace[];
invalidatesNamespaces?: readonly BuilderNamespace[];
retryOnConflict?: boolean;
requiresAssets?: boolean;
requiresConfirm?: boolean;
};
type ReadContract = Extract<RuntimeOperationContractInput, { kind: "read" }>;
type MutationContract = Extract<
RuntimeOperationContractInput,
{ kind: "mutation" }
>;
type RuntimeExecutionOutput<
Id extends RuntimeOutputSchemaId,
Contract extends RuntimeOperationContractInput,
> = Contract extends MutationContract
? BuilderRuntimeMutation<RuntimeOperationOutput<Id>>
: RuntimeOperationOutput<Id>;
const throwInvalidOperationInput = (
error: z.ZodError,
inputJsonSchema: InputJsonSchema
): never =>
throwBuilderValidationError(
"Operation input is invalid.",
getZodValidationIssues(error, inputJsonSchema)
);
const parseOperationInput = <Schema extends z.ZodTypeAny>(
schema: Schema,
input: unknown,
inputJsonSchema: InputJsonSchema
): z.infer<Schema> => {
const result = schema.safeParse(input ?? {});
if (result.success) {
return result.data;
}
const hasUnknownTransportField = result.error.issues.some(
(issue) =>
issue.code === "unrecognized_keys" &&
issue.keys.some((key) => key === "projectId" || key === "confirm")
);
if (
hasUnknownTransportField &&
typeof input === "object" &&
input !== null &&
Array.isArray(input) === false
) {
const {
projectId: _projectId,
confirm: _confirm,
...operationInput
} = input as Record<string, unknown>;
const operationResult = schema.safeParse(operationInput);
if (operationResult.success) {
return operationResult.data;
}
return throwInvalidOperationInput(operationResult.error, inputJsonSchema);
}
return throwInvalidOperationInput(result.error, inputJsonSchema);
};
const getScopedPropWarnings = ({
state,
instanceId,
path,
prop,
variables = [],
}: {
state: BuilderState;
instanceId: string;
path: string[];
prop: Parameters<typeof props.listPropExpressions>[0];
variables?: readonly string[];
}) =>
props
.listPropExpressions(prop)
.flatMap((entry) =>
getScopedExpressionWarnings(
state,
instanceId,
[...path, ...entry.path],
entry.expression,
entry.allowAssignment,
[...variables, ...entry.variables]
)
);
const withExpressionWarnings = <
Mutation extends { result: Record<string, unknown> },
>(
mutation: Mutation,
warnings: ReturnType<typeof getScopedExpressionWarnings>
) =>
warnings.length === 0
? mutation
: {
...mutation,
result: { ...mutation.result, warnings },
};
const runtimeOperation = <
Id extends RuntimeOutputSchemaId,
Schema extends z.ZodTypeAny,
Contract extends RuntimeOperationContractInput,
>(
id: Id,
publicApi: RuntimeOperationPublicApi,
contract: Contract,
inputSchema: Schema,
execute: (args: {
state: BuilderState;
input: z.output<Schema>;
context: BuilderRuntimeContext;
}) =>
| RuntimeExecutionOutput<Id, Contract>
| Promise<RuntimeExecutionOutput<Id, Contract>>
): BuilderRuntimeOperation<
Id,
z.input<Schema>,
RuntimeExecutionOutput<Id, Contract>
> => {
const writeNamespaces =
contract.kind === "mutation" ? contract.writeNamespaces : [];
const inputJsonSchema = getInputSchemaMetadata(inputSchema, {
isHiddenField: isHiddenPublicApiInputField,
}).inputJsonSchema;
const outputSchema = getRuntimeOutputSchema(id);
const executionOutputSchema =
contract.kind === "mutation"
? createRuntimeMutationExecutionSchema(outputSchema)
: outputSchema;
return {
id,
...publicApi,
kind: contract.kind,
inputSchema,
inputJsonSchema,
outputSchema,
outputJsonSchema: getInputSchemaMetadata(outputSchema).inputJsonSchema,
readNamespaces: contract.readNamespaces,
writeNamespaces,
invalidatesNamespaces:
contract.kind === "mutation"
? (contract.invalidatesNamespaces ?? contract.writeNamespaces)
: [],
retryOnConflict:
contract.kind === "mutation"
? (contract.retryOnConflict ?? false)
: false,
requiresAssets:
contract.requiresAssets ??
(contract.readNamespaces.includes("assets") ||
writeNamespaces.includes("assets")),
requiresConfirm:
contract.kind === "mutation"
? (contract.requiresConfirm ??
isDestructiveRuntimeCommand(publicApi.command))
: false,
execute: ({ state, input, context }) => {
const validateOutput = (value: unknown) => {
const parsed = executionOutputSchema.parse(value);
if (contract.kind === "mutation") {
for (const policy of mutationPolicies) {
policy.validate(
state,
parsed as BuilderRuntimeMutation<Record<string, unknown>>
);
}
}
return parsed as RuntimeExecutionOutput<Id, Contract>;
};
const result = execute({
state,
input: parseOperationInput(inputSchema, input, inputJsonSchema),
context,
});
if (result instanceof Promise) {
return result.then(validateOutput);
}
return validateOutput(result);
},
};
};
const api = (
command: string,
client: string,
permit?: BuilderApiCapability
): RuntimeOperationPublicApi => ({ command, client, permit });
export const isDestructiveRuntimeCommand = (command: string) =>
command.startsWith("delete-") ||
command.startsWith("replace-") ||
command === "set-redirects";
const readContract = (
readNamespaces: readonly BuilderNamespace[],
options: { requiresAssets?: boolean } = {}
): ReadContract => ({
kind: "read",
readNamespaces,
...options,
});
const mutationContract = (input: {
readNamespaces: readonly BuilderNamespace[];
writeNamespaces: readonly BuilderNamespace[];
invalidatesNamespaces?: readonly BuilderNamespace[];
retryOnConflict?: boolean;
requiresAssets?: boolean;
requiresConfirm?: boolean;
}): MutationContract => ({ kind: "mutation", ...input });
const pageNamespaces = ["pages", "instances"] as const;
const pageExpressionNamespaces = ["pages", "instances", "dataSources"] as const;
const instanceReadNamespaces = ["pages", "instances", "props"] as const;
const styleNamespaces = [
"styles",
"styleSources",
"styleSourceSelections",
] as const;
const dataNamespaces = ["dataSources", "resources"] as const;
const treeMutationNamespaces = [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
] as const;
const assetUsageNamespaces = [
"assets",
"pages",
"projectSettings",
"props",
"styles",
"resources",
"dataSources",
] as const;
const emptyInput = z.object({});
const contentBlockOperationInput = z.object({
blockInstanceId: z.string().min(1),
renderScope: z
.string()
.min(1)
.describe("Stable occurrence key; does not load route or resource data."),
variables: z
.record(z.string(), z.unknown())
.optional()
.describe(
'Concrete expression values. Result-one example: {post:{data:{id:"<mdxAssetId>"}}}.'
),
});
const contentBlockSourceInput = contentBlockOperationInput.extend({
source: contentBlockSourceSchema,
});
const contentBlockConnectSourceInput = contentBlockSourceInput.extend({
confirmReplacement: z.boolean().optional(),
});
const contentBlockEditSourceInput = contentBlockOperationInput.extend({
source: z.string(),
});
const contentBlockFrontmatterInput = contentBlockOperationInput.extend({
properties: z.record(z.string(), z.unknown()),
});
const contentBlockTemplateMigrationInput = z.object({
assetIds: z
.array(z.string().min(1))
.min(1)
.max(mdxTemplateMigrationFileLimit),
migration: z.union([
z.object({
type: z.literal("rename"),
from: z.string().min(1),
to: z
.string()
.min(1)
.refine(isMdxTemplateComponentName, "Use a PascalCase MDX name"),
}),
z.object({ type: z.literal("remove"), name: z.string().min(1) }),
]),
confirmationToken: z.string().optional(),
});
const requireContentBlockApplication = (context: BuilderRuntimeContext) => {
if (context.contentBlockApplication === undefined) {
return throwBuilderRuntimeError(
"CONFLICT",
"Content Block source operations require an Asset content session"
);
}
return context.contentBlockApplication;
};
const contentBlockNamespaces = [
"pages",
"instances",
"props",
"dataSources",
"resources",
"styleSources",
"styleSourceSelections",
"styles",
"breakpoints",
"assets",
] as const;
const pageListInput = z.object({
...paginatedOutputInputSchema.shape,
});
const pageGetInput = z.object({ pageId: z.string() });
const pageGetByPathInput = z.object({ path: z.string() });
const folderListInput = z.object({
...paginatedOutputInputSchema.shape,
});
const instanceListInput = instanceFilterInput.extend({
pageId: z.string().optional(),
pagePath: z.string().optional(),
rootInstanceId: z.string().optional(),
maxDepth: z.number().int().nonnegative().optional(),
topLevelOnly: z.boolean().optional(),
labelContains: z.string().optional(),
...paginatedOutputInputSchema.shape,
});
const instanceInspectInput = z.object({
instanceId: z.string(),
include: z
.array(
z.enum([
"props",
"styles",
"bindings",
"children",
"sources",
"ancestors",
])
)
.optional(),
childDepth: z.number().int().optional(),
});
const textListInput = z.object({
pageId: z.string().optional(),
pagePath: z.string().optional(),
instanceId: z.string().optional(),
mode: z.enum(["text", "expression", "all"]).optional(),
contains: z.string().optional(),
...paginatedOutputInputSchema.shape,
});
const styleDeclarationsListInput = z.object({
instanceIds: z.array(z.string()).optional(),
pageId: z.string().optional(),
pagePath: z.string().optional(),
breakpoint: z.string().optional(),
state: z.string().optional(),
property: z.string().optional(),
propertyFilter: z.string().optional(),
includeTokens: z.boolean().optional(),
...paginatedOutputInputSchema.shape,
});
const designTokenListInput = z.object({
filter: z.string().optional(),
withUsage: z
.boolean()
.optional()
.describe("Include usage counts. Defaults to true."),
sort: z.enum(["name", "usage"]).optional(),
...paginatedOutputInputSchema.shape,
});
const cssVariableListInput = z.object({
filter: z.string().optional(),
withUsage: z.boolean().optional(),
...paginatedOutputInputSchema.shape,
});
const scopedInstanceListInput = z.object({
scopeInstanceId: z.string().optional(),
...paginatedOutputInputSchema.shape,
});
const paginatedListInput = paginatedOutputInputSchema;
const assetListInput = z.object({
type: assetType.optional(),
sort: z.enum(["name", "size", "createdAt", "usage"]).optional(),
withUsage: z.boolean().optional(),
...paginatedOutputInputSchema.shape,
});
const assetUsageInput = z.object({
assetId: z.string(),
...paginatedOutputInputSchema.shape,
});
export const builderRuntimeOperations = [
runtimeOperation(
"contentBlocks.inspectSource",
api("inspect-content-block-source", "inspectContentBlockSource", "view"),
readContract(contentBlockNamespaces, { requiresAssets: true }),
contentBlockOperationInput,
async ({ state, input, context }) => {
const inspected = await requireContentBlockApplication(context).inspect({
state,
...input,
});
return {
source: inspected.source,
sessionStatus: inspected.sessionStatus,
identity: inspected.identity,
diagnostics: [...inspected.diagnostics],
};
}
),
runtimeOperation(
"contentBlocks.connectSource",
api("connect-content-block-source", "connectContentBlockSource", "edit"),
mutationContract({
readNamespaces: contentBlockNamespaces,
writeNamespaces: contentBlockNamespaces,
requiresAssets: true,
requiresConfirm: false,
}),
contentBlockConnectSourceInput,
async ({ state, input, context }) => {
const prepared = await requireContentBlockApplication(context).connect({
state,
...input,
});
return createRuntimeMutation({
payload:
prepared.requiresConfirmation && input.confirmReplacement !== true
? []
: [...prepared.projectPayload],
result: {
action: "connect" as const,
requiresConfirmation:
prepared.requiresConfirmation && input.confirmReplacement !== true,
diagnostics: [...prepared.inspection.diagnostics],
},
invalidatesNamespaces: contentBlockNamespaces,
});
}
),
runtimeOperation(
"contentBlocks.switchSource",
api("switch-content-block-source", "switchContentBlockSource", "edit"),
mutationContract({
readNamespaces: contentBlockNamespaces,
writeNamespaces: contentBlockNamespaces,
requiresAssets: true,
requiresConfirm: false,
}),
contentBlockSourceInput,
async ({ state, input, context }) => {
const prepared = await requireContentBlockApplication(
context
).switchSource({
state,
...input,
});
return createRuntimeMutation({
payload: [...prepared.projectPayload],
result: {
action: "switch" as const,
requiresConfirmation: false,
diagnostics: [...prepared.inspection.diagnostics],
},
invalidatesNamespaces: contentBlockNamespaces,
});
}
),
runtimeOperation(
"contentBlocks.disconnectSource",
api(
"disconnect-content-block-source",
"disconnectContentBlockSource",
"edit"
),
mutationContract({
readNamespaces: contentBlockNamespaces,
writeNamespaces: contentBlockNamespaces,
requiresAssets: true,
requiresConfirm: false,
}),
contentBlockOperationInput.extend({ confirm: z.boolean().optional() }),
async ({ state, input, context }) => {
const prepared = await requireContentBlockApplication(context).disconnect(
{
state,
...input,
}
);
return createRuntimeMutation({
payload: [...prepared.projectPayload],
result: {
action: "disconnect" as const,
requiresConfirmation: false,
diagnostics: [],
},
invalidatesNamespaces: contentBlockNamespaces,
});
}
),
runtimeOperation(
"contentBlocks.editSource",
api("edit-content-block-source", "editContentBlockSource", "edit"),
mutationContract({
readNamespaces: contentBlockNamespaces,
writeNamespaces: ["assets"],
requiresAssets: true,
requiresConfirm: false,
}),
contentBlockEditSourceInput,
async ({ state, input, context }) => {
const application = requireContentBlockApplication(context);
if (context.dryRun === true) {
const inspected = await application.previewSource({ state, ...input });
return createRuntimeMutation({
payload: [],
result: {
assetId: inspected.identity.assetId,
source: input.source,
status: inspected.state.status,
diagnostics: [...inspected.diagnostics],
},
invalidatesNamespaces: [],
});
}
const saved = await application.editSource({ state, ...input });
return createRuntimeMutation({
payload: [],
result: {
assetId: saved.state.asset.id,
source: saved.source,
status: saved.state.status,
diagnostics: [...saved.diagnostics],
},
invalidatesNamespaces: [],
});
}
),
runtimeOperation(
"contentBlocks.updateFrontmatter",
api(
"update-content-block-frontmatter",
"updateContentBlockFrontmatter",
"edit"
),
mutationContract({
readNamespaces: contentBlockNamespaces,
writeNamespaces: ["assets"],
requiresAssets: true,
requiresConfirm: false,
}),
contentBlockFrontmatterInput,
async ({ state, input, context }) => {
const application = requireContentBlockApplication(context);
if (context.dryRun === true) {
const preview = await application.previewFrontmatter({
state,
...input,
});
return createRuntimeMutation({
payload: [],
result: {
assetId: preview.identity.assetId,
source: preview.source,
status: preview.state.status,
diagnostics: [...preview.diagnostics],
},
invalidatesNamespaces: [],
});
}
const saved = await application.updateFrontmatter({ state, ...input });
return createRuntimeMutation({
payload: [],
result: {
assetId: saved.state.asset.id,
source: saved.source,
status: saved.state.status,
diagnostics: [...saved.diagnostics],
},
invalidatesNamespaces: [],
});
}
),
runtimeOperation(
"contentBlocks.reloadSource",
api("reload-content-block-source", "reloadContentBlockSource", "view"),
readContract(contentBlockNamespaces, { requiresAssets: true }),
contentBlockOperationInput,
async ({ state, input, context }) => {
const reloaded = await requireContentBlockApplication(context).reload({
state,
...input,
});
const inspected = await requireContentBlockApplication(context).inspect({
state,
...input,
});
return {
assetId: reloaded.asset.id,
source: reloaded.source,
status: reloaded.status,
diagnostics: [...inspected.diagnostics],
};
}
),
runtimeOperation(
"contentBlocks.migrateTemplateReferences",
api(
"migrate-content-block-template-references",
"migrateContentBlockTemplateReferences",
"edit"
),
mutationContract({
readNamespaces: contentBlockNamespaces,
writeNamespaces: ["assets"],
requiresAssets: true,
requiresConfirm: false,
}),
contentBlockTemplateMigrationInput,
async ({ input, context }) => {
const result = await requireContentBlockApplication(
context
).migrateTemplateReferences({
...input,
dryRun: context.dryRun,
});
return createRuntimeMutation({
payload: [],
result: {
status: result.status,
updateCount: result.updateCount,
omissionCount: result.omissionCount,
changedFileCount: result.changedFileCount,
files: result.files.map((file) => ({
assetId: file.assetId,
revision: file.revision,
contentRef: file.contentRef,
changed: file.changed,
...("status" in file ? { status: file.status } : {}),
updateCount: file.updateCount,
omissionCount: file.omissionCount,
diagnostics: file.diagnostics.map(({ code, message }) => ({
code,
message,
})),
})),
...(result.status === "confirmation-required"
? {
confirmation: {
token: result.confirmationToken,
expiresAt: result.confirmationExpiresAt,
},
}
: {}),
},
invalidatesNamespaces: [],
});
}
),
runtimeOperation(
"pages.list",
api("list-pages", "listPages"),
readContract(["pages"]),
pageListInput,
({ state, input }) => pages.listPages(state, input)
),
runtimeOperation(
"pages.get",
api("get-page", "getPage"),
readContract(pageNamespaces),
pageGetInput,
({ state, input }) => pages.getPage(state, input)
),
runtimeOperation(
"pages.getByPath",
api("get-page-by-path", "getPageByPath"),
readContract(pageNamespaces),
pageGetByPathInput,
({ state, input }) => pages.getPageByPath(state, input)
),
runtimeOperation(
"pages.create",
api("create-page", "createPage"),
mutationContract({
readNamespaces: pageExpressionNamespaces,
writeNamespaces: pageNamespaces,
}),
pages.pageCreateInput,
({ state, input, context }) => pages.createPage(state, input, context)
),
runtimeOperation(
"pages.update",
api("update-page", "updatePage"),
mutationContract({
readNamespaces: pageExpressionNamespaces,
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.pageUpdateInput,
({ state, input }) => pages.updatePage(state, input)
),
runtimeOperation(
"pages.updateSettings",
api("update-page-settings", "updatePageSettings", "edit"),
mutationContract({
readNamespaces: pageExpressionNamespaces,
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.pageSettingsUpdateInput,
({ state, input }) => pages.updatePageSettings(state, input)
),
runtimeOperation(
"pages.updateMarketplace",
api("update-page-marketplace", "updatePageMarketplace"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.pageMarketplaceUpdateInput,
({ state, input }) => pages.updatePageMarketplace(state, input)
),
runtimeOperation(
"pages.savePathInHistory",
api("save-page-path-history", "savePagePathInHistory"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.pageSavePathInHistoryInput,
({ state, input }) => pages.savePagePathInHistory(state, input)
),
runtimeOperation(
"pages.setHome",
api("set-home-page", "setHomePage"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.pageSetHomeInput,
({ state, input }) => pages.setHomePage(state, input)
),
runtimeOperation(
"projectSettings.get",
api("get-project-settings", "getProjectSettings"),
readContract(["pages", "projectSettings"]),
outputDetailInputSchema,
({ state, input }) => projectSettings.getProjectSettings(state, input)
),
runtimeOperation(
"projectSettings.update",
api("update-project-settings", "updateProjectSettings"),
mutationContract({
readNamespaces: ["projectSettings"],
writeNamespaces: ["projectSettings"],
retryOnConflict: true,
}),
projectSettings.projectSettingsUpdateInput,
({ state, input }) => projectSettings.updateProjectSettings(state, input)
),
runtimeOperation(
"responseHeaders.list",
api("list-response-headers", "listResponseHeaders"),
readContract(["projectSettings"]),
paginatedListInput,
({ state, input }) => projectSettings.listResponseHeaders(state, input)
),
runtimeOperation(
"responseHeaders.set",
api("set-response-header", "setResponseHeader"),
mutationContract({
readNamespaces: ["projectSettings"],
writeNamespaces: ["projectSettings"],
retryOnConflict: true,
}),
projectSettings.responseHeaderSetInput,
({ state, input }) => projectSettings.setResponseHeader(state, input)
),
runtimeOperation(
"responseHeaders.delete",
api("delete-response-header", "deleteResponseHeader"),
mutationContract({
readNamespaces: ["projectSettings"],
writeNamespaces: ["projectSettings"],
retryOnConflict: true,
}),
projectSettings.responseHeaderDeleteInput,
({ state, input }) => projectSettings.deleteResponseHeader(state, input)
),
runtimeOperation(
"projectSettings.getMarketplaceProduct",
api("get-marketplace-product", "getMarketplaceProduct"),
readContract(["marketplaceProduct"]),
emptyInput,
({ state }) => projectSettings.getMarketplaceProduct(state)
),
runtimeOperation(
"projectSettings.updateMarketplaceProduct",
api("update-marketplace-product", "updateMarketplaceProduct"),
mutationContract({
readNamespaces: [],
writeNamespaces: ["marketplaceProduct"],
retryOnConflict: true,
}),
projectSettings.marketplaceProductUpdateInput,
({ state, input }) => projectSettings.updateMarketplaceProduct(state, input)
),
runtimeOperation(
"redirects.list",
api("list-redirects", "listRedirects"),
readContract(["pages"]),
paginatedListInput,
({ state, input }) => projectSettings.listRedirects(state, input)
),
runtimeOperation(
"redirects.create",
api("create-redirect", "createRedirect"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
projectSettings.redirectCreateInput,
({ state, input }) => projectSettings.createRedirect(state, input)
),
runtimeOperation(
"redirects.update",
api("update-redirect", "updateRedirect"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
projectSettings.redirectUpdateInput,
({ state, input }) => projectSettings.updateRedirect(state, input)
),
runtimeOperation(
"redirects.delete",
api("delete-redirect", "deleteRedirect"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
projectSettings.redirectDeleteInput,
({ state, input }) => projectSettings.deleteRedirect(state, input)
),
runtimeOperation(
"redirects.setAll",
api("set-redirects", "setRedirects"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
projectSettings.redirectSetAllInput,
({ state, input }) => projectSettings.setRedirects(state, input)
),
runtimeOperation(
"breakpoints.list",
api("list-breakpoints", "listBreakpoints"),
readContract(["breakpoints"]),
paginatedListInput,
({ state, input }) => projectSettings.listBreakpoints(state, input)
),
runtimeOperation(
"breakpoints.create",
api("create-breakpoint", "createBreakpoint"),
mutationContract({
readNamespaces: ["breakpoints"],
writeNamespaces: ["breakpoints"],
retryOnConflict: true,
}),
projectSettings.breakpointCreateInput,
({ state, input, context }) =>
projectSettings.createBreakpoint(state, input, context)
),
runtimeOperation(
"breakpoints.update",
api("update-breakpoint", "updateBreakpoint"),
mutationContract({
readNamespaces: ["breakpoints"],
writeNamespaces: ["breakpoints"],
retryOnConflict: true,
}),
projectSettings.breakpointUpdateInput,
({ state, input }) => projectSettings.updateBreakpoint(state, input)
),
runtimeOperation(
"breakpoints.delete",
api("delete-breakpoint", "deleteBreakpoint"),
mutationContract({
readNamespaces: ["breakpoints", "styles"],
writeNamespaces: ["breakpoints", "styles"],
retryOnConflict: true,
}),
projectSettings.breakpointDeleteInput,
({ state, input }) => projectSettings.deleteBreakpoint(state, input)
),
runtimeOperation(
"pages.delete",
api("delete-page", "deletePage"),
mutationContract({
readNamespaces: treeMutationNamespaces,
writeNamespaces: treeMutationNamespaces,
}),
pages.pageDeleteInput,
({ state, input }) => pages.deletePage(state, input)
),
runtimeOperation(
"pages.duplicate",
api("duplicate-page", "duplicatePage"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageDuplicateInput,
({ state, input, context }) => pageCopy.duplicatePage(state, input, context)
),
runtimeOperation(
"pages.copy",
api("copy-page", "copyPage"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageCopyInput,
({ state, input, context }) => pageCopy.copyPage(state, input, context)
),
runtimeOperation(
"pageTemplates.list",
api("list-page-templates", "listPageTemplates"),
readContract(["pages"]),
paginatedListInput,
({ state, input }) => pageCopy.listPageTemplates(state, input)
),
runtimeOperation(
"pageTemplates.create",
api("create-page-template", "createPageTemplate"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageTemplateCreateInput,
({ state, input, context }) =>
pageCopy.createPageTemplate(state, input, context)
),
runtimeOperation(
"pageTemplates.update",
api("update-page-template", "updatePageTemplate"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
retryOnConflict: true,
}),
pageCopy.pageTemplateUpdateInput,
({ state, input }) => pageCopy.updatePageTemplate(state, input)
),
runtimeOperation(
"pageTemplates.delete",
api("delete-page-template", "deletePageTemplate"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageTemplateDeleteInput,
({ state, input }) => pageCopy.deletePageTemplate(state, input)
),
runtimeOperation(
"pageTemplates.duplicate",
api("duplicate-page-template", "duplicatePageTemplate"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageTemplateDuplicateInput,
({ state, input, context }) =>
pageCopy.duplicatePageTemplate(state, input, context)
),
runtimeOperation(
"pageTemplates.reorder",
api("reorder-page-template", "reorderPageTemplate"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pageCopy.pageTemplateReorderInput,
({ state, input }) => pageCopy.reorderPageTemplates(state, input)
),
runtimeOperation(
"pageTemplates.createPage",
api("create-page-from-template", "createPageFromTemplate", "edit"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageTemplateCreatePageInput,
({ state, input, context }) =>
pageCopy.createPageFromTemplate(state, input, context)
),
runtimeOperation(
"folders.list",
api("list-folders", "listFolders"),
readContract(["pages"]),
folderListInput,
({ state, input }) => pages.listFolders(state, input)
),
runtimeOperation(
"folders.create",
api("create-folder", "createFolder"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
}),
pages.folderCreateInput,
({ state, input, context }) => pages.createFolder(state, input, context)
),
runtimeOperation(
"folders.update",
api("update-folder", "updateFolder"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.folderUpdateInput,
({ state, input }) => pages.updateFolder(state, input)
),
runtimeOperation(
"folders.delete",
api("delete-folder", "deleteFolder"),
mutationContract({
readNamespaces: treeMutationNamespaces,
writeNamespaces: treeMutationNamespaces,
}),
pages.folderDeleteInput,
({ state, input }) => pages.deleteFolder(state, input)
),
runtimeOperation(
"folders.duplicate",
api("duplicate-folder", "duplicateFolder"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.folderDuplicateInput,
({ state, input, context }) =>
pageCopy.duplicateFolder(state, input, context)
),
runtimeOperation(
"pageTransfer.insert",
api("insert-page-transfer-item", "insertPageTransferItem"),
mutationContract({
readNamespaces: pageCopyNamespaces,
writeNamespaces: pageCopyNamespaces,
}),
pageCopy.pageTransferInsertInput,
({ state, input, context }) =>
pageCopy.insertPageTransferItem(state, input, context)
),
runtimeOperation(
"pageTree.move",
api("move-page-tree-item", "movePageTreeItem"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
pages.pageTreeMoveInput,
({ state, input }) => pages.movePageTreeItem(state, input)
),
runtimeOperation(
"pageTree.reparentOrphans",
api("reparent-page-tree-orphans", "reparentPageTreeOrphans"),
mutationContract({
readNamespaces: ["pages"],
writeNamespaces: ["pages"],
retryOnConflict: true,
}),
emptyInput,
({ state }) => pages.reparentOrphans(state)
),
runtimeOperation(
"instances.list",
api("list-instances", "listInstances"),
readContract(instanceReadNamespaces),
instanceListInput,
({ state, input }) => instances.listInstances(state, input)
),
runtimeOperation(
"instances.inspect",
api("inspect-instance", "inspectInstance"),
readContract([
"instances",
"props",
"styles",
"styleSources",
"styleSourceSelections",
]),
instanceInspectInput,
({ state, input }) => instances.inspectInstance(state, input)
),
runtimeOperation(
"project.search",
api("search-project", "searchProject"),
readContract([
"pages",
"projectSettings",
"instances",
"props",
"styles",
"styleSources",
"styleSourceSelections",
"resources",
"dataSources",
"assets",
"assetFolders",
"breakpoints",
"marketplaceProduct",
]),
projectSearch.projectSearchInput,
({ state, input }) => projectSearch.searchProject(state, input)
),
runtimeOperation(
"project.audit",
api("audit", "audit"),
readContract([
"pages",
"projectSettings",
"instances",
"props",
"styles",
"styleSources",
"styleSourceSelections",
"resources",
"dataSources",
"assets",
"breakpoints",
]),
audit.auditInput,
({ state, input, context }) => audit.audit(state, input, context)
),
runtimeOperation(
"project.verifyBindings",
api("verify-bindings", "verifyBindings"),
readContract(["pages", "instances", "props", "resources", "dataSources"]),
bindingVerification.bindingVerificationInput,
({ state, input }) => bindingVerification.verifyBindings(state, input)
),
runtimeOperation(
"runtimeUi.integrate",
api("integrate-runtime-ui", "integrateRuntimeUi"),
mutationContract({
readNamespaces: components.componentInsertReadNamespaces,
writeNamespaces: components.componentInsertReadNamespaces,
}),
runtimeUi.integrateRuntimeUiInput,
({ state, input, context }) =>
runtimeUi.integrateRuntimeUi(state, input, context)
),
runtimeOperation(
"instances.insertComponent",
api("insert-component", "insertComponent"),
mutationContract({
readNamespaces: components.componentInsertReadNamespaces,
writeNamespaces: components.componentInsertNamespaces,
}),
components.insertComponentInput,
({ state, input, context }) =>
components.insertComponent(state, input, context)
),
runtimeOperation(
"instances.insertMdxText",
api("insert-mdx-text", "insertMdxText"),
mutationContract({
readNamespaces: components.componentInsertReadNamespaces,
writeNamespaces: components.componentInsertNamespaces,
}),
mdxPaste.insertMdxTextInput,
({ state, input, context }) =>
mdxPaste.insertMdxText({ state, input, context })
),
runtimeOperation(
"instances.insertCollection",
api("insert-collection", "insertCollection"),
mutationContract({
readNamespaces: components.componentInsertReadNamespaces,
writeNamespaces: components.componentInsertNamespaces,
}),
collection.insertCollectionInput,
({ state, input, context }) => {
const warnings = [
...(input.data.type === "expression"
? getScopedExpressionWarnings(
state,
input.parentInstanceId,
["data", "value"],
input.data.value
)
: []),
...listFragmentExpressions(input.itemFragment).flatMap((entry) =>
getScopedExpressionWarnings(
state,
input.parentInstanceId,
["itemFragment", ...entry.path],
entry.expression,
entry.allowAssignment,
["collectionItem", "collectionItemKey", ...entry.variables]
)
),
];
return withExpressionWarnings(
components.insertCollection(state, input, context),
warnings
);
}
),
runtimeOperation(
"instances.insertFragment",
api("insert-fragment", "insertFragment", "edit"),
mutationContract({
readNamespaces: components.componentInsertReadNamespaces,
writeNamespaces: components.componentInsertNamespaces,
}),
components.insertFragmentInput,
({ state, input, context }) =>
components.insertFragment(state, input, context)
),
runtimeOperation(
"slots.attach",
api("attach-slot", "attachSharedSlot"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["instances"],
}),
slot.attachSharedSlotInput,
({ state, input, context }) => slot.attachSharedSlot(state, input, context)
),
runtimeOperation(
"slots.extract",
api("extract-slot", "extractSharedSlot"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["instances"],
}),
slot.extractSharedSlotInput,
({ state, input, context }) => slot.extractSharedSlot(state, input, context)
),
runtimeOperation(
"instances.move",
api("move-instance", "moveInstance"),
mutationContract({
readNamespaces: ["pages", "instances", "props", ...dataNamespaces],
writeNamespaces: ["pages", "instances", "props", ...dataNamespaces],
}),
instances.moveInstancesInput,
({ state, input }) => instances.moveInstances(state, input)
),
runtimeOperation(
"instances.reparent",
api("reparent-instance", "reparentInstance", "edit"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
"assets",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
"assets",
],
}),
instances.reparentInstanceInput,
({ state, input, context }) =>
instances.reparentInstance(state, input, context)
),
runtimeOperation(
"instances.fillGrid",
api("fill-grid", "fillGrid"),
mutationContract({
readNamespaces: treeMutationNamespaces,
writeNamespaces: [
"instances",
"styleSourceSelections",
"styleSources",
"styles",
],
}),
instances.fillGridInput,
({ state, input, context }) => instances.fillGrid(state, input, context)
),
runtimeOperation(
"instances.wrap",
api("wrap-instance", "wrapInstance"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["instances"],
}),
instances.wrapInstanceInput,
({ state, input, context }) => instances.wrapInstance(state, input, context)
),
runtimeOperation(
"instances.convert",
api("convert-instance", "convertInstance"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
"dataSources",
"resources",
"styleSourceSelections",
"styleSources",
"styles",
"breakpoints",
"assets",
],
writeNamespaces: [
"instances",
"props",
"dataSources",
"resources",
"styleSourceSelections",
"styleSources",
"styles",
"breakpoints",
"assets",
],
}),
instances.convertInstanceInput,
({ state, input, context }) =>
instances.convertInstance(state, input, context)
),
runtimeOperation(
"instances.unwrap",
api("unwrap-instance", "unwrapInstance"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["instances"],
}),
instances.unwrapInstanceInput,
({ state, input, context }) =>
instances.unwrapInstance(state, input, context)
),
runtimeOperation(
"instances.clone",
api("clone-instance", "cloneInstance"),
mutationContract({
readNamespaces: instanceDuplicate.instanceDuplicateNamespaces,
writeNamespaces: instanceDuplicate.instanceDuplicateNamespaces,
}),
instanceDuplicate.cloneInstanceInput,
({ state, input, context }) =>
instanceDuplicate.cloneInstance(state, input, context)
),
runtimeOperation(
"instances.duplicateAfterItself",
api("duplicate-instance", "duplicateInstance"),
mutationContract({
readNamespaces: instanceDuplicate.instanceDuplicateNamespaces,
writeNamespaces: instanceDuplicate.instanceDuplicateNamespaces,
}),
instanceDuplicate.duplicateInstanceAfterItselfInput,
({ state, input, context }) =>
instanceDuplicate.duplicateInstanceAfterItself(state, input, context)
),
runtimeOperation(
"instances.delete",
api("delete-instance", "deleteInstance", "edit"),
mutationContract({
readNamespaces: treeMutationNamespaces,
writeNamespaces: treeMutationNamespaces,
}),
instances.deleteInstancesInput,
({ state, input }) => instances.deleteInstances(state, input)
),
runtimeOperation(
"instances.deleteBySelector",
api("delete-instance-by-selector", "deleteInstanceBySelector", "edit"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
"assets",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
"assets",
],
}),
instances.deleteInstanceBySelectorInput,
({ state, input, context }) =>
instances.deleteInstanceBySelector(state, input, context)
),
runtimeOperation(
"instances.updateProps",
api("update-props", "updateProps", "edit"),
mutationContract({
readNamespaces: ["instances", "props", "dataSources", "assets"],
writeNamespaces: ["props"],
}),
props.propUpdatesInput,
({ state, input, context }) => {
const warnings = input.updates.flatMap((update, index) =>
getScopedPropWarnings({
state,
instanceId: update.instanceId,
path: ["updates", String(index), "value"],
prop: update,
})
);
return withExpressionWarnings(
props.updateProps(
state,
{
updates: input.updates.map((update) =>
update.type === "expression"
? {
...update,
value: bindExpressionInput(
state,
update.instanceId,
update.value
),
}
: update
),
},
context
),
warnings
);
}
),
runtimeOperation(
"instances.replacePropText",
api("replace-prop-text", "replacePropText", "edit"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["props"],
retryOnConflict: true,
}),
props.replacePropTextInput,
({ state, input }) => props.replacePropText(state, input)
),
runtimeOperation(
"instances.deleteProps",
api("delete-props", "deleteProps", "edit"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["props", "resources"],
}),
props.propDeletionsInput,
({ state, input }) => props.deleteProps(state, input)
),
runtimeOperation(
"instances.bindProps",
api("bind-props", "bindProps"),
mutationContract({
readNamespaces: ["instances", "props", ...dataNamespaces],
writeNamespaces: ["props"],
}),
props.propBindingsInput,
({ state, input, context }) => {
const warnings = input.bindings.flatMap((binding, index) =>
getScopedPropWarnings({
state,
instanceId: binding.instanceId,
path: ["bindings", String(index), "binding", "value"],
prop: binding.binding,
})
);
return withExpressionWarnings(
props.bindProps(
state,
{
bindings: input.bindings.map((binding) => {
if (binding.binding.type === "expression") {
return {
...binding,
binding: {
...binding.binding,
value: bindExpressionInput(
state,
binding.instanceId,
binding.binding.value
),
},
};
}
if (binding.binding.type === "action") {
return {
...binding,
binding: {
...binding.binding,
value: binding.binding.value.map((action) => ({
...action,
code: bindExpressionInput(
state,
binding.instanceId,
action.code,
action.args
),
})),
},
};
}
return binding;
}),
},
context
),
warnings
);
}
),
runtimeOperation(
"instances.listTexts",
api("list-texts", "listTexts"),
readContract(["pages", "instances"]),
textListInput,
({ state, input }) => instances.listTextInstances(state, input)
),
runtimeOperation(
"instances.updateText",
api("update-text", "updateText", "edit"),
mutationContract({
readNamespaces: ["instances", "props", "dataSources"],
writeNamespaces: ["instances"],
retryOnConflict: true,
}),
instances.updateTextInstanceInput,
({ state, input }) => {
const warnings =
input.mode === "expression"
? getScopedExpressionWarnings(
state,
input.instanceId,
["text"],
input.text
)
: [];
return withExpressionWarnings(
instances.updateTextInstance(
state,
input.mode === "expression"
? {
...input,
text: bindExpressionInput(state, input.instanceId, input.text),
}
: input
),
warnings
);
}
),
runtimeOperation(
"instances.replaceText",
api("replace-text", "replaceText", "edit"),
mutationContract({
readNamespaces: ["pages", "instances"],
writeNamespaces: ["instances"],
retryOnConflict: true,
}),
instances.replaceTextInput,
({ state, input }) => instances.replaceText(state, input)
),
runtimeOperation(
"instances.setTextContent",
api("set-text-content", "setTextContent", "edit"),
mutationContract({
readNamespaces: ["instances", "props", "dataSources"],
writeNamespaces: ["instances"],
retryOnConflict: true,
}),
instances.setTextContentInput,
({ state, input }) => {
const warnings =
input.operation === "set" && input.mode === "expression"
? getScopedExpressionWarnings(
state,
input.instanceId,
["text"],
input.text
)
: [];
return withExpressionWarnings(
instances.setTextContent(
state,
input.operation === "set" && input.mode === "expression"
? {
...input,
text: bindExpressionInput(state, input.instanceId, input.text),
}
: input
),
warnings
);
}
),
runtimeOperation(
"instances.updateTextTree",
api("update-text-tree", "updateTextTree", "edit"),
mutationContract({
readNamespaces: [
"instances",
"props",
"dataSources",
"styleSources",
"styleSourceSelections",
"styles",
],
writeNamespaces: [
"instances",
"props",
"dataSources",
"resources",
"styleSourceSelections",
"styleSources",
"styles",
],
retryOnConflict: true,
}),
instances.updateTextTreeInput,
({ state, input, context }) =>
instances.updateTextTree(state, input, context)
),
runtimeOperation(
"instances.setTag",
api("set-instance-tag", "setInstanceTag", "edit"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["instances", "props"],
retryOnConflict: true,
}),
instances.setInstanceTagInput,
({ state, input }) => instances.setInstanceTag(state, input)
),
runtimeOperation(
"instances.setLabel",
api("set-instance-label", "setInstanceLabel", "edit"),
mutationContract({
readNamespaces: ["instances"],
writeNamespaces: ["instances"],
retryOnConflict: true,
}),
instances.setInstanceLabelInput,
({ state, input }) => instances.setInstanceLabel(state, input)
),
runtimeOperation(
"instances.setName",
api("set-instance-name", "setInstanceName", "edit"),
mutationContract({
readNamespaces: ["instances", "props"],
writeNamespaces: ["instances"],
retryOnConflict: true,
}),
instances.setInstanceNameInput,
({ state, input }) => instances.setInstanceName(state, input)
),
runtimeOperation(
"styles.getDeclarations",
api("get-styles", "getStyleDeclarations"),
readContract(["instances", ...styleNamespaces, "breakpoints"]),
styleDeclarationsListInput,
({ state, input }) => styles.getStyleDeclarations(state, input)
),
runtimeOperation(
"styles.updateDeclarations",
api("update-styles", "updateStyleDeclarations"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
styles.styleUpdateDeclarationsInput,
({ state, input, context }) =>
styles.updateStyleDeclarations(state, input, context)
),
runtimeOperation(
"styles.deleteDeclarations",
api("delete-styles", "deleteStyleDeclarations"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles"],
retryOnConflict: true,
}),
styles.styleDeleteDeclarationsInput,
({ state, input }) => styles.deleteStyleDeclarations(state, input)
),
runtimeOperation(
"styles.updateSelectedDeclarations",
api("update-selected-styles", "updateSelectedStyleDeclarations"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
styles.selectedStyleUpdateDeclarationsInput,
({ state, input }) => styles.updateSelectedStyleDeclarations(state, input)
),
runtimeOperation(
"styles.deleteSelectedDeclarations",
api("delete-selected-styles", "deleteSelectedStyleDeclarations"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles"],
}),
styles.selectedStyleDeleteDeclarationsInput,
({ state, input }) => styles.deleteSelectedStyleDeclarations(state, input)
),
runtimeOperation(
"styles.replaceValues",
api("replace-styles", "replaceStyleValues"),
mutationContract({
readNamespaces: ["pages", "instances", ...styleNamespaces],
writeNamespaces: ["styles"],
}),
styles.styleReplaceInput,
({ state, input }) => styles.replaceStyleValues(state, input)
),
runtimeOperation(
"designTokens.list",
api("list-design-tokens", "listDesignTokens"),
readContract(styleNamespaces),
designTokenListInput,
({ state, input }) => styles.listDesignTokens(state, input)
),
runtimeOperation(
"designTokens.create",
api("create-design-token", "createDesignTokens"),
mutationContract({
readNamespaces: [...styleNamespaces, "breakpoints"],
writeNamespaces: ["styleSources", "styles"],
}),
styles.designTokenCreateManyInput,
({ state, input, context }) =>
styles.createDesignTokens(state, input, context)
),
runtimeOperation(
"designTokens.import",
api("import-design-tokens", "importDesignTokens"),
mutationContract({
readNamespaces: ["pages", ...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
designTokenImport.designTokenImportInput,
({ state, input, context }) =>
designTokenImport.importDesignTokens(state, input, context)
),
runtimeOperation(
"designTokens.createAttached",
api("create-attached-design-token", "createAttachedDesignTokens"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces, "breakpoints"],
writeNamespaces: ["styleSources", "styles", "styleSourceSelections"],
}),
styles.designTokenCreateAttachedInput,
({ state, input, context }) =>
styles.createAttachedDesignTokens(state, input, context)
),
runtimeOperation(
"designTokens.updateStyles",
api("update-design-token-styles", "updateDesignTokenStyles"),
mutationContract({
readNamespaces: [...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles", "styleSources"],
}),
styles.designTokenStyleUpdatesInput,
({ state, input }) => styles.updateDesignTokenStyles(state, input)
),
runtimeOperation(
"designTokens.deleteStyles",
api("delete-design-token-styles", "deleteDesignTokenStyles"),
mutationContract({
readNamespaces: [...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles"],
}),
styles.designTokenStyleDeletionsInput,
({ state, input }) => styles.deleteDesignTokenStyles(state, input)
),
runtimeOperation(
"designTokens.attach",
api("attach-design-token", "attachDesignToken"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces],
writeNamespaces: ["styleSourceSelections"],
}),
styles.designTokenAttachInput,
({ state, input }) => styles.attachDesignToken(state, input)
),
runtimeOperation(
"designTokens.detach",
api("detach-design-token", "detachDesignToken"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces],
writeNamespaces: ["styleSourceSelections"],
}),
styles.designTokenDetachInput,
({ state, input }) => styles.detachDesignToken(state, input)
),
runtimeOperation(
"designTokens.extract",
api("extract-design-token", "extractDesignToken"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces],
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
styles.designTokenExtractInput,
({ state, input, context }) =>
styles.extractDesignToken(state, input, context)
),
runtimeOperation(
"styleSources.rename",
api("rename-style-source", "renameStyleSource"),
mutationContract({
readNamespaces: ["styleSources"],
writeNamespaces: ["styleSources"],
}),
styles.styleSourceRenameInput,
({ state, input }) => styles.renameStyleSource(state, input)
),
runtimeOperation(
"styleSources.delete",
api("delete-style-source", "deleteStyleSources"),
mutationContract({
readNamespaces: styleNamespaces,
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
styles.styleSourceDeleteInput,
({ state, input }) => styles.deleteStyleSources(state, input)
),
runtimeOperation(
"styleSources.setLock",
api("set-style-source-lock", "setStyleSourceLock"),
mutationContract({
readNamespaces: ["styleSources"],
writeNamespaces: ["styleSources"],
}),
styles.styleSourceLockInput,
({ state, input }) => styles.setStyleSourceLock(state, input)
),
runtimeOperation(
"styleSources.reorder",
api("reorder-style-sources", "reorderStyleSources"),
mutationContract({
readNamespaces: ["instances", "styleSources", "styleSourceSelections"],
writeNamespaces: ["styleSourceSelections"],
}),
styles.styleSourceReorderInput,
({ state, input }) => styles.reorderStyleSources(state, input)
),
runtimeOperation(
"styleSources.clearStyles",
api("clear-style-source-styles", "clearStyleSourceStyles"),
mutationContract({
readNamespaces: ["styles", "styleSources"],
writeNamespaces: ["styles"],
requiresConfirm: true,
}),
styles.styleSourceClearStylesInput,
({ state, input }) => styles.clearStyleSourceStyles(state, input)
),
runtimeOperation(
"styleSources.duplicate",
api("duplicate-style-source", "duplicateStyleSource"),
mutationContract({
readNamespaces: ["instances", ...styleNamespaces],
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
styles.styleSourceDuplicateInput,
({ state, input, context }) =>
styles.duplicateStyleSource(state, input, context)
),
runtimeOperation(
"styleSources.convertLocalToToken",
api(
"convert-local-style-source-to-token",
"convertLocalStyleSourceToToken"
),
mutationContract({
readNamespaces: ["instances", "styleSources", "styleSourceSelections"],
writeNamespaces: ["styleSources", "styleSourceSelections"],
}),
styles.styleSourceConvertLocalToTokenInput,
({ state, input, context }) =>
styles.convertLocalStyleSourceToToken(state, input, context)
),
runtimeOperation(
"cssVariables.list",
api("list-css-variables", "listCssVariables"),
readContract([...styleNamespaces, "props"]),
cssVariableListInput,
({ state, input }) => styles.listCssVariables(state, input)
),
runtimeOperation(
"cssVariables.define",
api("define-css-variable", "defineCssVariables"),
mutationContract({
readNamespaces: [...styleNamespaces, "breakpoints"],
writeNamespaces: ["styles", "styleSources", "styleSourceSelections"],
}),
styles.cssVariableDefineInput,
({ state, input, context }) =>
styles.defineCssVariables(state, input, context)
),
runtimeOperation(
"cssVariables.delete",
api("delete-css-variable", "deleteCssVariables"),
mutationContract({
readNamespaces: [...styleNamespaces, "props"],
writeNamespaces: ["styles"],
requiresConfirm: true,
}),
styles.cssVariableDeleteInput,
({ state, input }) => styles.deleteCssVariables(state, input)
),
runtimeOperation(
"cssVariables.rewriteRefs",
api("rewrite-css-variable-refs", "rewriteCssVariableRefs"),
mutationContract({
readNamespaces: [...styleNamespaces, "props"],
writeNamespaces: ["styles", "props"],
}),
styles.cssVariableRewriteRefsInput,
({ state, input }) => styles.rewriteCssVariableRefs(state, input)
),
runtimeOperation(
"cssVariables.rename",
api("rename-css-variable", "renameCssVariable"),
mutationContract({
readNamespaces: [...styleNamespaces, "props"],
writeNamespaces: ["styles", "props"],
}),
styles.cssVariableRenameInput,
({ state, input }) => styles.renameCssVariable(state, input)
),
runtimeOperation(
"variables.list",
api("list-variables", "listVariables"),
readContract(["dataSources"]),
scopedInstanceListInput,
({ state, input }) => data.listDataVariables(state, input)
),
runtimeOperation(
"variables.create",
api("create-variable", "createVariable"),
mutationContract({
readNamespaces: ["pages", "instances", "props", ...dataNamespaces],
writeNamespaces: ["pages", "instances", "props", ...dataNamespaces],
}),
data.dataVariableCreateInput,
({ state, input, context }) =>
data.createDataVariable(state, input, context)
),
runtimeOperation(
"variables.update",
api("update-variable", "updateVariable"),
mutationContract({
readNamespaces: ["pages", "instances", "props", ...dataNamespaces],
writeNamespaces: ["pages", "instances", "props", ...dataNamespaces],
retryOnConflict: true,
}),
data.dataVariableUpdateInput,
({ state, input }) => data.updateDataVariable(state, input)
),
runtimeOperation(
"variables.delete",
api("delete-variable", "deleteVariable"),
mutationContract({
readNamespaces: ["pages", "instances", "props", ...dataNamespaces],
writeNamespaces: ["pages", "instances", "props", ...dataNamespaces],
}),
data.dataVariableDeleteInput,
({ state, input }) => data.deleteDataVariable(state, input)
),
runtimeOperation(
"variables.deleteUnused",
api("delete-unused-variables", "deleteUnusedVariables"),
mutationContract({
readNamespaces: ["pages", "instances", "props", ...dataNamespaces],
writeNamespaces: ["pages", "instances", "props", ...dataNamespaces],
}),
data.dataVariableDeleteUnusedInput,
({ state, input }) => data.deleteUnusedDataVariables(state, input)
),
runtimeOperation(
"resources.list",
api("list-resources", "listResources"),
readContract(dataNamespaces),
scopedInstanceListInput,
({ state, input }) => data.listResources(state, input)
),
runtimeOperation(
"assetsResources.list",
api("list-assets-resources", "listAssetsResources"),
readContract(dataNamespaces),
assetResources.assetsResourceListInput,
({ state, input }) => assetResources.listAssetsResources(state, input)
),
runtimeOperation(
"assetsResources.get",
api("get-assets-resource", "getAssetsResource"),
readContract(dataNamespaces),
assetResources.assetsResourceGetInput,
({ state, input }) => assetResources.getAssetsResource(state, input)
),
runtimeOperation(
"assetsResources.create",
api("create-assets-resource", "createAssetsResource"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
}),
assetResources.assetsResourceCreateInput,
({ state, input, context }) =>
assetResources.createAssetsResource(state, input, context)
),
runtimeOperation(
"assetsResources.update",
api("update-assets-resource", "updateAssetsResource"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
}),
assetResources.assetsResourceUpdateInput,
({ state, input, context }) =>
assetResources.updateAssetsResource(state, input, context)
),
runtimeOperation(
"resources.create",
api("create-resource", "createResource"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
}),
data.resourceCreateInput,
({ state, input, context }) => data.createResource(state, input, context)
),
runtimeOperation(
"resources.update",
api("update-resource", "updateResource"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
}),
data.resourceUpdateInput,
({ state, input, context }) => data.updateResource(state, input, context)
),
runtimeOperation(
"resources.replaceText",
api("replace-resource-text", "replaceResourceText"),
mutationContract({
readNamespaces: ["resources"],
writeNamespaces: ["resources"],
retryOnConflict: true,
}),
data.replaceResourceTextInput,
({ state, input }) => data.replaceResourceText(state, input)
),
runtimeOperation(
"resources.upsert",
api("upsert-resource", "upsertResource"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
}),
data.resourceUpsertInput,
({ state, input, context }) => data.upsertResource(state, input, context)
),
runtimeOperation(
"resources.upsertProp",
api("upsert-resource-prop", "upsertResourceProp"),
mutationContract({
readNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
writeNamespaces: [
"pages",
"instances",
"props",
...dataNamespaces,
...styleNamespaces,
"breakpoints",
],
}),
data.resourcePropUpsertInput,
({ state, input, context }) =>
data.upsertResourceProp(state, input, context)
),
runtimeOperation(
"resources.delete",
api("delete-resource", "deleteResource"),
mutationContract({
readNamespaces: ["pages", "instances", ...dataNamespaces, "props"],
writeNamespaces: [...dataNamespaces, "props"],
}),
data.resourceDeleteInput,
({ state, input }) => data.deleteResource(state, input)
),
runtimeOperation(
"assetFolders.list",
api("list-asset-folders", "listAssetFolders"),
readContract(["assetFolders"], { requiresAssets: true }),
assetFolders.assetFolderListInput,
({ state, input }) => assetFolders.listAssetFolders(state, input)
),
runtimeOperation(
"assetFolders.create",
api("create-asset-folder", "createAssetFolder", "edit"),
mutationContract({
readNamespaces: ["assetFolders"],
writeNamespaces: ["assetFolders"],
retryOnConflict: true,
requiresAssets: true,
}),
assetFolders.assetFolderCreateInput,
({ state, input, context }) =>
assetFolders.createAssetFolder(state, input, context)
),
runtimeOperation(
"assetFolders.update",
api("update-asset-folder", "updateAssetFolder"),
mutationContract({
readNamespaces: ["assetFolders"],
writeNamespaces: ["assetFolders"],
requiresAssets: true,
}),
assetFolders.assetFolderUpdateInput,
({ state, input }) => assetFolders.updateAssetFolder(state, input)
),
runtimeOperation(
"assetFolders.delete",
api("delete-asset-folder", "deleteAssetFolder"),
mutationContract({
readNamespaces: ["assetFolders", "assets"],
writeNamespaces: ["assetFolders", "assets"],
requiresAssets: true,
}),
assetFolders.assetFolderDeleteInput,
({ state, input }) => assetFolders.deleteAssetFolder(state, input)
),
runtimeOperation(
"assetFolders.duplicate",
api("duplicate-asset-folder", "duplicateAssetFolder"),
mutationContract({
readNamespaces: ["assetFolders", "assets"],
writeNamespaces: ["assetFolders", "assets"],
retryOnConflict: true,
requiresAssets: true,
}),
assetFolders.assetFolderDuplicateInput,
({ state, input, context }) =>
assetFolders.duplicateAssetFolder(state, input, context)
),
runtimeOperation(
"assets.list",
api("list-assets", "listAssets"),
readContract(assetUsageNamespaces, { requiresAssets: true }),
assetListInput,
({ state, input }) => assets.listAssets(state, input)
),
runtimeOperation(
"assets.get",
api("get-asset", "getAsset"),
readContract(["assets"], { requiresAssets: true }),
assets.assetGetInput,
({ state, input }) => assets.getAsset(state, input)
),
runtimeOperation(
"fonts.list",
api("list-fonts", "listFonts"),
readContract(["assets"]),
fonts.fontListInput,
({ state, input }) => fonts.listFonts(state, input)
),
runtimeOperation(
"assets.findUsage",
api("find-asset-usage", "findAssetUsage"),
readContract(assetUsageNamespaces, { requiresAssets: true }),
assetUsageInput,
({ state, input }) => assets.findAssetUsage(state, input)
),
runtimeOperation(
"assets.update",
api("update-asset", "updateAsset"),
mutationContract({
readNamespaces: ["assets", "assetFolders"],
writeNamespaces: ["assets"],
requiresAssets: true,
}),
assets.assetUpdateInput,
({ state, input }) => assets.updateAsset(state, input)
),
runtimeOperation(
"assets.setImageDescriptions",
api("set-image-descriptions", "setImageDescriptions"),
mutationContract({
readNamespaces: ["assets"],
writeNamespaces: ["assets"],
requiresAssets: true,
}),
assets.imageDescriptionsSetInput,
({ state, input }) => assets.setImageDescriptions(state, input)
),
runtimeOperation(
"assets.add",
api("add-asset", "addAsset"),
mutationContract({
readNamespaces: ["assets", "assetFolders"],
writeNamespaces: ["assets"],
retryOnConflict: true,
requiresAssets: true,
}),
assets.assetAddInput,
({ state, input, context }) => assets.addAsset(state, input, context)
),
runtimeOperation(
"assets.duplicate",
api("duplicate-asset", "duplicateAsset"),
mutationContract({
readNamespaces: ["assets", "assetFolders"],
writeNamespaces: ["assets"],
retryOnConflict: true,
requiresAssets: true,
}),
assets.assetDuplicateInput,
({ state, input, context }) => assets.duplicateAsset(state, input, context)
),
runtimeOperation(
"assets.replace",
api("replace-asset", "replaceAsset"),
mutationContract({
readNamespaces: assetUsageNamespaces,
writeNamespaces: [
"pages",
"projectSettings",
"props",
"styles",
"assets",
],
requiresAssets: true,
}),
assets.assetReplaceInput,
({ state, input }) => assets.replaceAsset(state, input)
),
runtimeOperation(
"assets.delete",
api("delete-asset", "deleteAssets"),
mutationContract({
readNamespaces: assetUsageNamespaces,
writeNamespaces: ["assets"],
requiresAssets: true,
}),
assets.assetDeleteInput,
({ state, input }) => assets.deleteAssets(state, input)
),
] as const satisfies readonly BuilderRuntimeOperation[];
const internalBuilderRuntimeOperations = [
runtimeOperation(
"system.migrateLoadedData",
api("migrate-loaded-data", "migrateLoadedData"),
mutationContract({
readNamespaces: builderNamespaces,
writeNamespaces: builderNamespaces,
retryOnConflict: true,
}),
migrations.migrateLoadedDataInput,
({ state }) => migrations.migrateLoadedData(state)
),
] as const satisfies readonly BuilderRuntimeOperation[];
const allBuilderRuntimeOperations = [
...builderRuntimeOperations,
...internalBuilderRuntimeOperations,
] as const satisfies readonly BuilderRuntimeOperation[];
export type BuilderRuntimeOperationId =
(typeof allBuilderRuntimeOperations)[number]["id"];
export type BuilderRuntimeOperationInput<Id extends string> = Id extends unknown
? Extract<
(typeof allBuilderRuntimeOperations)[number],
{ id: Id }
> extends BuilderRuntimeOperation<Id, infer Input, unknown>
? Input
: never
: never;
export type BuilderRuntimeOperationResult<Id extends string> =
Id extends unknown
? Extract<
(typeof allBuilderRuntimeOperations)[number],
{ id: Id }
> extends BuilderRuntimeOperation<Id, unknown, infer Result>
? Result
: never
: never;
export type BuilderRuntimeMutationOperationId = {
[Id in BuilderRuntimeOperationId]: BuilderRuntimeOperationResult<Id> extends BuilderRuntimeMutation
? Id
: never;
}[BuilderRuntimeOperationId];
const builderRuntimeOperationById: ReadonlyMap<
string,
BuilderRuntimeOperation
> = new Map(
allBuilderRuntimeOperations.map((operation) => [operation.id, operation])
);
export const getBuilderRuntimeOperation = (id: string) => {
const operation = builderRuntimeOperationById.get(id);
if (operation === undefined) {
throw new Error(`Unknown builder runtime operation "${id}".`);
}
return operation;
};
export const getBuilderRuntimeOperationInputSchema = (id: string) =>
getBuilderRuntimeOperation(id).inputSchema;
export const executeBuilderRuntimeOperation = <Result = unknown>({
id,
state,
input,
context = builderRuntimeContext,
}: {
id: string;
state: BuilderState;
input: unknown;
context?: BuilderRuntimeContext;
}): Result | Promise<Result> => {
return getBuilderRuntimeOperation(id).execute({
state,
input,
context,
}) as Result;
};