Skip to content

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.

96.3 KB
Raw Blame
import {
  type Asset,
  collectionComponent,
  dataSourceVariableValue,
  decodeDataVariableId,
  decodeDataSourceVariable,
  encodeDataVariableId,
  encodeDataSourceVariable,
  findTreeInstanceIds,
  findTreeInstanceIdsExcludingSlotDescendants,
  getAllPages,
  getParentInstanceById,
  getStyleDeclKey,
  isAssetsResource,
  isFormSubmission,
  isEmailBindingDataSourceAvailable,
  ROOT_INSTANCE_ID,
  resource,
  SYSTEM_VARIABLE_ID,
  systemParameter,
  type DataSource,
  type DataSources,
  type Instance,
  type Instances,
  type Pages,
  type Prop,
  type Props,
  type Resource,
  type Resources,
  type WebstudioData,
} from "@webstudio-is/sdk";
import {
  getExpressionIdentifiers,
  isLiteralExpression,
  parseJsonExpression,
  parseStringLiteralExpression,
  transpileExpression,
} from "@webstudio-is/expression";
import { z } from "zod";
import {
  validateContactEmail,
  validateEmailSender,
} from "../contracts/project-settings";
import { produceWithPatches } from "immer";
import {
  browserInfoParameterName,
  createJsonStringifyProxy,
  formDataParameterName,
  isPlainObject,
  isStringifyProxy,
} from "@webstudio-is/sdk/runtime";
import type { CompactBuild } from "../types";
import {
  compactBuilderPatchPayload,
  type BuilderPatchChange,
} from "../contracts/patch";
import { createBuilderPatchPayloadFromImmerPatches } from "../state/patch";
import type { BuilderState } from "../state/builder-state";
import "../state/immer";
import type { BuilderRuntimeContext } from "./context";
import {
  addZodValidationIssue,
  formatValidationIssueMessages,
  prefixValidationIssuePaths,
  throwBuilderRuntimeError,
  throwBuilderValidationError,
  type SemanticValidationIssue,
} from "./errors";
import { replaceTextValue } from "./text-replacement";
import {
  getNamedExpressionErrors,
  getNamedExpressionValidationIssues,
  getExpressionWarnings,
  hasExpressionDiagnostics,
} from "./expression-validation";
import { runtimeGeneratedIdInput } from "./generated-id-input";
import { createRuntimeMutation } from "./mutation";
import {
  paginateOutput,
  projectOutput,
  type PaginatedOutputInput,
} from "./output";
import {
  createPropUpsertPayload,
  createValidatedPropValueFromInput,
  findProp,
} from "./props";

const getRequiredDataSources = (state: Pick<BuilderState, "dataSources">) => {
  if (state.dataSources === undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Data sources namespace is missing"
    );
  }
  return state.dataSources;
};

const getRequiredResources = (state: Pick<BuilderState, "resources">) => {
  if (state.resources === undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Resources namespace is missing"
    );
  }
  return state.resources;
};

const getRequiredProps = (state: Pick<BuilderState, "props">) => {
  if (state.props === undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Props namespace is missing"
    );
  }
  return state.props;
};

const getRequiredBuildData = (
  state: Pick<
    BuilderState,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >
) => {
  const missing = (
    [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
      "breakpoints",
      "styleSources",
      "styleSourceSelections",
      "styles",
    ] as const
  ).find((namespace) => state[namespace] === undefined);
  if (missing !== undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      `${missing} namespace is missing`
    );
  }
  return {
    pages: state.pages!,
    instances: Array.from(state.instances!.values()),
    props: Array.from(state.props!.values()),
    dataSources: Array.from(state.dataSources!.values()),
    resources: Array.from(state.resources!.values()),
    breakpoints: Array.from(state.breakpoints!.values()),
    styleSources: Array.from(state.styleSources!.values()),
    styleSourceSelections: Array.from(state.styleSourceSelections!.values()),
    styles: Array.from(state.styles!.values()),
  };
};

export const findDataVariable = (
  dataSources: Iterable<DataSource>,
  dataSourceId: DataSource["id"]
) => {
  for (const dataSource of dataSources) {
    if (dataSource.id === dataSourceId && dataSource.type === "variable") {
      return dataSource;
    }
  }
};

export const serializeDataVariables = ({
  dataSources,
  scopeInstanceId,
}: {
  dataSources: Iterable<DataSource> | Map<string, DataSource>;
  scopeInstanceId?: Instance["id"];
}) => ({
  variables: (dataSources instanceof Map
    ? Array.from(dataSources.values())
    : Array.from(dataSources)
  )
    .filter((dataSource) => dataSource.type === "variable")
    .filter(
      (dataSource) =>
        scopeInstanceId === undefined ||
        dataSource.scopeInstanceId === scopeInstanceId
    )
    .map((dataSource) => ({
      id: dataSource.id,
      name: dataSource.name,
      scopeInstanceId: dataSource.scopeInstanceId,
      value: dataSource.value,
    })),
});

export const listDataVariables = (
  state: Pick<BuilderState, "dataSources">,
  input: { scopeInstanceId?: string } & PaginatedOutputInput = {}
) => {
  const serialized = serializeDataVariables({
    dataSources: getRequiredDataSources(state),
    scopeInstanceId: input.scopeInstanceId,
  });
  const { items, ...pagination } = paginateOutput({
    items: serialized.variables.map((variable) =>
      projectOutput({
        input,
        compact: {
          id: variable.id,
          name: variable.name,
          scopeInstanceId: variable.scopeInstanceId,
          valueType: variable.value.type,
        },
        expanded: () => ({ value: variable.value }),
      })
    ),
    cursor: input.cursor,
    limit: input.limit,
    filters: { scopeInstanceId: input.scopeInstanceId },
    verbose: input.verbose,
  });
  return { variables: items, ...pagination };
};

export const dataVariableValueInput = dataSourceVariableValue;

const resourceScopeInstanceIdDescription = `Instance ID or ${JSON.stringify(ROOT_INSTANCE_ID)} for Global Root.`;
export const resourceScopeInstanceIdInput = z
  .string()
  .describe(resourceScopeInstanceIdDescription);
export const optionalResourceScopeInstanceIdInput = z
  .string()
  .optional()
  .describe(resourceScopeInstanceIdDescription);

export const dataVariableCreateInput = z.object({
  dataSourceId: runtimeGeneratedIdInput,
  scopeInstanceId: resourceScopeInstanceIdInput,
  name: z.string().min(1),
  value: dataVariableValueInput,
});

export const dataVariableUpdateInput = z.object({
  dataSourceId: z.string(),
  values: z.object({
    scopeInstanceId: optionalResourceScopeInstanceIdInput,
    name: z.string().min(1).optional(),
    value: dataVariableValueInput.optional(),
  }),
});

export const dataVariableDeleteInput = z.object({
  dataSourceId: z.string(),
});

export const dataVariableDeleteUnusedInput = z.object({});

type DataVariable = Extract<DataSource, { type: "variable" }>;
type DataVariableValue = DataVariable["value"];
export type DataVariableValueType = DataVariableValue["type"];

export type DataVariableNameError = {
  type: "required" | "duplicate";
  message: string;
};

export const validateDataVariableNameWithSources = ({
  dataSources,
  name,
  variableId,
  scopeInstanceId,
}: {
  dataSources: Iterable<DataSource>;
  name: string;
  variableId?: DataSource["id"];
  scopeInstanceId?: Instance["id"];
}): DataVariableNameError | undefined => {
  if (name.trim().length === 0) {
    return {
      type: "required",
      message: "Variable name is required",
    };
  }

  for (const dataSource of dataSources) {
    if (
      (dataSource.type === "variable" ||
        dataSource.type === "resource" ||
        dataSource.type === "parameter") &&
      dataSource.scopeInstanceId === scopeInstanceId &&
      dataSource.name === name &&
      dataSource.id !== variableId
    ) {
      return {
        type: "duplicate",
        message: "Name is already used by another variable on this instance",
      };
    }
  }
};

export const validateDataVariableNumberValue = (value: string | number) => {
  if (typeof value === "string" && value.length === 0) {
    return "Value expects a number";
  }
  const number = Number(value);
  return Number.isNaN(number) ? "Invalid number" : "";
};

export const getDataVariableJsonExpressionErrors = (expression: string) => {
  return getNamedExpressionErrors("value", expression);
};

export const validateDataVariableJsonValue = (expression: string) => {
  return getDataVariableJsonExpressionErrors(expression).length > 0 ||
    hasExpressionDiagnostics({ expression })
    ? "error"
    : "";
};

export const createDataVariableValueFromInput = ({
  type,
  value,
}: {
  type: DataVariableValueType;
  value: string | null;
}): DataVariableValue => {
  if (type === "string") {
    return { type: "string", value: value ?? "" };
  }
  if (type === "number") {
    return { type: "number", value: Number(value || 0) };
  }
  if (type === "boolean") {
    return { type: "boolean", value: value !== null };
  }
  const parsedValue = value ? parseJsonExpression(value) : null;
  return {
    type: "json",
    value: parsedValue ?? null,
  };
};

const allowedJsChars = /[A-Za-z_]/;
const compiledExpressionCacheLimit = 10_000;
type CompiledExpression = (variables: {
  get: (key: DataSource["name"]) => unknown;
  // Dynamic expressions intentionally preserve the historical `any` result.
  // eslint-disable-next-line @typescript-eslint/no-explicit-any
}) => any;

const compiledExpressionCache = new Map<string, CompiledExpression>();

const setUnion = <Item>(current: Set<Item>, other: Set<Item>) => {
  const result = new Set<Item>(current);
  for (const item of other) {
    result.add(item);
  }
  return result;
};

const getCompiledExpression = (expression: string) => {
  const cached = compiledExpressionCache.get(expression);
  if (cached) {
    return cached;
  }

  const usedVariables = new Map<string, DataSource["name"]>();
  const transpiled = transpileExpression({
    expression,
    executable: true,
    replaceVariable: (identifier) => {
      const id = decodeDataVariableId(identifier);
      if (id) {
        usedVariables.set(identifier, id);
      } else {
        const name = decodeDataVariableName(identifier);
        usedVariables.set(identifier, name);
      }
    },
  });
  let code = "";
  for (const [identifier, name] of usedVariables) {
    code += `let ${identifier} = _variables.get(${JSON.stringify(name)});\n`;
  }
  code += `return (${transpiled})`;

  const compiledExpression = new Function(
    "_variables",
    code
  ) as CompiledExpression;
  compiledExpressionCache.set(expression, compiledExpression);
  if (compiledExpressionCache.size > compiledExpressionCacheLimit) {
    const oldestExpression = compiledExpressionCache.keys().next().value;
    if (oldestExpression !== undefined) {
      compiledExpressionCache.delete(oldestExpression);
    }
  }
  return compiledExpression;
};

export const encodeDataVariableName = (name: string) => {
  let encodedName = "";
  for (let index = 0; index < name.length; index += 1) {
    const char = name[index];
    encodedName += allowedJsChars.test(char)
      ? char
      : `$${char.codePointAt(0)}$`;
  }
  return encodedName;
};

export const decodeDataVariableName = (identifier: string) => {
  const name = identifier.replaceAll(/\$(\d+)\$/g, (_match, code) =>
    String.fromCodePoint(code)
  );
  return name;
};

export const unsetExpressionVariables = ({
  expression,
  unsetNameById,
}: {
  expression: string;
  unsetNameById: Map<DataSource["id"], DataSource["name"]>;
}) => {
  try {
    return transpileExpression({
      expression,
      replaceVariable: (identifier) => {
        const id = decodeDataVariableId(identifier);
        if (id) {
          const name = unsetNameById.get(id);
          if (name) {
            return encodeDataVariableName(name);
          }
        }
        return identifier;
      },
    });
  } catch {
    return expression;
  }
};

export const restoreExpressionVariables = ({
  expression,
  maskedIdByName,
}: {
  expression: string;
  maskedIdByName: Map<DataSource["name"], DataSource["id"]>;
}) => {
  try {
    return transpileExpression({
      expression,
      replaceVariable: (identifier) => {
        const name = decodeDataVariableName(identifier);
        if (name) {
          const id = maskedIdByName.get(name);
          if (id) {
            return encodeDataVariableId(id);
          }
        }
        return identifier;
      },
    });
  } catch {
    return expression;
  }
};

export const replaceDataSourcesInExpression = (
  expression: string,
  replacements: Map<DataSource["id"], DataSource["id"]>
) => {
  try {
    return transpileExpression({
      expression,
      replaceVariable: (identifier) => {
        const dataSourceId = decodeDataSourceVariable(identifier);
        if (dataSourceId === undefined) {
          return;
        }
        return encodeDataSourceVariable(
          replacements.get(dataSourceId) ?? dataSourceId
        );
      },
    });
  } catch {
    // Resource fields historically also store plain strings such as URLs.
    // Copy those values unchanged instead of treating them as expressions.
    return expression;
  }
};

/** Evaluate already-resolved values with the same compiler used by Builder bindings. */
export const evaluateExpressionSync = (
  expression: string,
  variables: ReadonlyMap<DataSource["name"], unknown>,
  { throwOnError = false }: { throwOnError?: boolean } = {}
) => {
  try {
    const proxiedVariables = new Map<DataSource["name"], unknown>();
    const getVariable = (key: DataSource["name"]) => {
      if (proxiedVariables.has(key)) {
        return proxiedVariables.get(key);
      }
      const value = variables.get(key);
      const proxiedValue =
        isPlainObject(value) && !isStringifyProxy(value)
          ? createJsonStringifyProxy(
              Object.isFrozen(value) ? structuredClone(value) : value
            )
          : value;
      proxiedVariables.set(key, proxiedValue);
      return proxiedValue;
    };

    const result = getCompiledExpression(expression)({ get: getVariable });
    return result;
  } catch (error) {
    if (throwOnError) {
      throw error;
    }
    return undefined;
  }
};

export type ResolveExpressionDataSource = (
  dataSourceId: DataSource["id"],
  value: unknown
) => unknown | PromiseLike<unknown>;

const resolveExpressionVariables = async ({
  expression,
  variables,
  resolveDataSource,
}: {
  expression: string;
  variables: ReadonlyMap<DataSource["id"], unknown>;
  resolveDataSource: ResolveExpressionDataSource;
}) => {
  const dataSourceIds = new Set<DataSource["id"]>();
  for (const identifier of getExpressionIdentifiers(expression)) {
    const dataSourceId = decodeDataVariableId(identifier);
    if (dataSourceId !== undefined) {
      dataSourceIds.add(dataSourceId);
    }
  }
  const resolved = new Map(variables);
  await Promise.all(
    [...dataSourceIds].map(async (dataSourceId) => {
      resolved.set(
        dataSourceId,
        await resolveDataSource(dataSourceId, variables.get(dataSourceId))
      );
    })
  );
  return resolved;
};

export const computeExpression = async (
  expression: string,
  variables: ReadonlyMap<DataSource["id"], unknown>,
  resolveDataSource: ResolveExpressionDataSource = (_dataSourceId, value) =>
    value
) =>
  evaluateExpressionSync(
    expression,
    await resolveExpressionVariables({
      expression,
      variables,
      resolveDataSource,
    })
  );

export const computeStringExpression = async (
  expression: string,
  variables: ReadonlyMap<DataSource["id"], unknown>,
  resolveDataSource?: ResolveExpressionDataSource
) => {
  const value = await computeExpression(
    expression,
    variables,
    resolveDataSource
  );
  return typeof value === "string" && value !== "" ? value : undefined;
};

export const computeExpressionWithinScope = async (
  expression: string,
  scope: Record<string, unknown>,
  resolveDataSource?: ResolveExpressionDataSource
) => {
  if (expression.trim() === "") {
    return;
  }
  const variables = new Map<DataSource["id"], unknown>();
  for (const [name, value] of Object.entries(scope)) {
    const dataSourceId = decodeDataVariableId(name);
    if (dataSourceId !== undefined) {
      variables.set(dataSourceId, value);
    }
  }
  return computeExpression(expression, variables, resolveDataSource);
};

const getDataSourcesByScopeInstanceId = (dataSources: DataSources) => {
  const dataSourcesByScopeInstanceId = new Map<
    Instance["id"],
    Array<DataSource>
  >();
  for (const dataSource of dataSources.values()) {
    const instanceId = dataSource.scopeInstanceId ?? ROOT_INSTANCE_ID;
    const dataSourcesByScope =
      dataSourcesByScopeInstanceId.get(instanceId) ?? [];
    dataSourcesByScope.push(dataSource);
    dataSourcesByScopeInstanceId.set(instanceId, dataSourcesByScope);
  }
  return dataSourcesByScopeInstanceId;
};

const findVariablesByInstanceId = ({
  startingInstanceId,
  parentInstanceById,
  instances,
  dataSources,
  dataSourcesByScopeInstanceId = getDataSourcesByScopeInstanceId(dataSources),
}: {
  startingInstanceId: Instance["id"];
  parentInstanceById: Map<Instance["id"], Instance["id"]>;
  instances: Instances;
  dataSources: DataSources;
  dataSourcesByScopeInstanceId?: Map<Instance["id"], Array<DataSource>>;
}) => {
  let currentId: undefined | string = startingInstanceId;
  const instanceIdsPath: Instance["id"][] = [];
  while (currentId) {
    instanceIdsPath.push(currentId);
    currentId = parentInstanceById.get(currentId);
  }
  instanceIdsPath.push(ROOT_INSTANCE_ID);
  const maskedIdByName = new Map<DataSource["name"], DataSource["id"]>();
  const availableDataSourceIds = new Set<DataSource["id"]>([
    SYSTEM_VARIABLE_ID,
  ]);
  maskedIdByName.set("system", SYSTEM_VARIABLE_ID);
  for (const instanceId of instanceIdsPath.reverse()) {
    const instance = instances.get(instanceId);
    const scopedDataSources = dataSourcesByScopeInstanceId.get(instanceId);
    if (scopedDataSources === undefined) {
      continue;
    }
    for (const dataSource of scopedDataSources) {
      if (
        instanceId === startingInstanceId &&
        instance?.component === collectionComponent &&
        dataSource.type === "parameter"
      ) {
        continue;
      }
      maskedIdByName.set(dataSource.name, dataSource.id);
      availableDataSourceIds.add(dataSource.id);
    }
  }
  return { maskedIdByName, availableDataSourceIds };
};

export const createFindAvailableVariables = ({
  instances,
  dataSources,
}: {
  instances: Instances;
  dataSources: DataSources;
}) => {
  // These indexes depend only on the project data, not on the starting
  // instance. Reuse them when resolving variables for many template roots.
  const parentInstanceById = getParentInstanceById(instances);
  const dataSourcesByScopeInstanceId =
    getDataSourcesByScopeInstanceId(dataSources);

  return (startingInstanceId: Instance["id"]) => {
    const { maskedIdByName } = findVariablesByInstanceId({
      startingInstanceId,
      parentInstanceById,
      instances,
      dataSources,
      dataSourcesByScopeInstanceId,
    });
    const availableVariables: DataSource[] = [];
    for (const dataSourceId of maskedIdByName.values()) {
      const dataSource = dataSources.get(dataSourceId);
      if (dataSource) {
        availableVariables.push(dataSource);
      }
      if (dataSourceId === SYSTEM_VARIABLE_ID) {
        availableVariables.push(systemParameter);
      }
    }
    return availableVariables;
  };
};

export const findAvailableVariables = ({
  startingInstanceId,
  instances,
  dataSources,
}: {
  startingInstanceId: Instance["id"];
  instances: Instances;
  dataSources: DataSources;
}) => {
  return createFindAvailableVariables({ instances, dataSources })(
    startingInstanceId
  );
};

export const bindExpressionToInstanceScope = ({
  expression,
  instanceId,
  instances,
  dataSources,
  excludeVariableNames = [],
}: {
  expression: string;
  instanceId: Instance["id"];
  instances: Instances;
  dataSources: DataSources;
  excludeVariableNames?: Iterable<string>;
}) => {
  const { maskedIdByName, availableDataSourceIds } = findVariablesByInstanceId({
    startingInstanceId: instanceId,
    parentInstanceById: getParentInstanceById(instances),
    instances,
    dataSources,
  });
  for (const name of excludeVariableNames) {
    maskedIdByName.delete(name);
  }
  const boundExpression = restoreExpressionVariables({
    expression,
    maskedIdByName,
  });
  for (const identifier of getExpressionIdentifiers(boundExpression)) {
    const dataSourceId = decodeDataVariableId(identifier);
    if (
      dataSourceId !== undefined &&
      availableDataSourceIds.has(dataSourceId) === false
    ) {
      return throwBuilderRuntimeError(
        "BAD_REQUEST",
        `Expression references data source "${dataSourceId}", which is not available to instance "${instanceId}". Read the target instance and its current Collection subtree again, then use an in-scope variable name or parameter from that subtree.`
      );
    }
  }
  return boundExpression;
};

/** Apply expression rebinding consistently to every Resource expression field. */
export const mapResourceExpressionsMutable = (
  resource: Resource,
  map: (expression: string) => void | string
) => {
  const update = (expression: string, set: (value: string) => void) => {
    const next = map(expression);
    if (next !== undefined) {
      set(next);
    }
  };
  update(resource.url, (value) => (resource.url = value));
  for (const entry of [...resource.headers, ...(resource.searchParams ?? [])]) {
    update(entry.value, (value) => (entry.value = value));
  }
  if (resource.body !== undefined) {
    update(resource.body, (value) => (resource.body = value));
  }
  if (resource.email) {
    for (const key of [
      "senderExpression",
      "recipientsExpression",
      "subject",
      "body",
    ] as const) {
      const expression = resource.email[key];
      if (expression !== undefined) {
        update(expression, (value) => (resource.email![key] = value));
      }
    }
  }
};

const traverseExpressions = ({
  startingInstanceId,
  pages,
  instances,
  props,
  dataSources,
  resources,
  update,
}: {
  startingInstanceId: undefined | Instance["id"];
  pages: undefined | Pages;
  instances: Instances;
  props: Props;
  dataSources: DataSources;
  resources: Resources;
  update: (
    expression: string,
    instanceId: Instance["id"],
    args?: string[]
  ) => void | string;
}) => {
  const pagesList = pages ? getAllPages(pages) : [];
  const updateExpression = ({
    expression,
    instanceId,
    args,
    set,
  }: {
    expression: string;
    instanceId: Instance["id"];
    args?: string[];
    set: (nextExpression: string) => void;
  }) => {
    const nextExpression = update(expression, instanceId, args);
    if (nextExpression !== undefined) {
      set(nextExpression);
    }
  };

  let instanceIds =
    startingInstanceId === undefined
      ? new Set(instances.keys())
      : findTreeInstanceIdsExcludingSlotDescendants(
          instances,
          startingInstanceId
        );
  for (const page of pagesList) {
    if (startingInstanceId === ROOT_INSTANCE_ID) {
      instanceIds = setUnion(
        instanceIds,
        findTreeInstanceIds(instances, page.rootInstanceId)
      );
    }

    if (
      startingInstanceId === page.rootInstanceId ||
      startingInstanceId === ROOT_INSTANCE_ID
    ) {
      const { rootInstanceId } = page;
      updateExpression({
        expression: page.title,
        instanceId: rootInstanceId,
        set: (expression) => (page.title = expression),
      });
      if (page.meta.description) {
        updateExpression({
          expression: page.meta.description,
          instanceId: rootInstanceId,
          set: (expression) => (page.meta.description = expression),
        });
      }
      if (page.meta.excludePageFromSearch) {
        updateExpression({
          expression: page.meta.excludePageFromSearch,
          instanceId: rootInstanceId,
          set: (expression) => (page.meta.excludePageFromSearch = expression),
        });
      }
      if (page.meta.socialImageUrl) {
        updateExpression({
          expression: page.meta.socialImageUrl,
          instanceId: rootInstanceId,
          set: (expression) => (page.meta.socialImageUrl = expression),
        });
      }
      if (page.meta.language) {
        updateExpression({
          expression: page.meta.language,
          instanceId: rootInstanceId,
          set: (expression) => (page.meta.language = expression),
        });
      }
      if (page.meta.status) {
        updateExpression({
          expression: page.meta.status,
          instanceId: rootInstanceId,
          set: (expression) => (page.meta.status = expression),
        });
      }
      if (page.meta.redirect) {
        updateExpression({
          expression: page.meta.redirect,
          instanceId: rootInstanceId,
          set: (expression) => (page.meta.redirect = expression),
        });
      }
      if (page.meta.custom) {
        for (const item of page.meta.custom) {
          updateExpression({
            expression: item.content,
            instanceId: rootInstanceId,
            set: (expression) => (item.content = expression),
          });
        }
      }
    }
  }
  const instanceIdByResourceId = new Map<Resource["id"], Instance["id"]>();

  for (const instance of instances.values()) {
    if (instanceIds.has(instance.id) === false) {
      continue;
    }
    for (const child of instance.children) {
      if (child.type === "expression") {
        updateExpression({
          expression: child.value,
          instanceId: instance.id,
          set: (expression) => (child.value = expression),
        });
      }
    }
  }

  for (const prop of props.values()) {
    if (instanceIds.has(prop.instanceId) === false) {
      continue;
    }
    if (prop.type === "expression") {
      updateExpression({
        expression: prop.value,
        instanceId: prop.instanceId,
        set: (expression) => (prop.value = expression),
      });
      continue;
    }
    if (prop.type === "action") {
      for (const action of prop.value) {
        updateExpression({
          expression: action.code,
          instanceId: prop.instanceId,
          args: action.args,
          set: (expression) => (action.code = expression),
        });
      }
      continue;
    }
    if (prop.type === "resource") {
      instanceIdByResourceId.set(prop.value, prop.instanceId);
      continue;
    }
  }

  for (const dataSource of dataSources.values()) {
    const instanceId = dataSource.scopeInstanceId ?? ROOT_INSTANCE_ID;
    if (instanceIds.has(instanceId) && dataSource.type === "resource") {
      instanceIdByResourceId.set(dataSource.resourceId, instanceId);
    }
  }

  for (const resource of resources.values()) {
    const instanceId = instanceIdByResourceId.get(resource.id);
    if (instanceId === undefined) {
      continue;
    }
    mapResourceExpressionsMutable(resource, (expression) =>
      update(expression, instanceId)
    );
  }
};

export const findUnsetVariableNames = ({
  instances,
  props,
  dataSources,
  resources,
}: {
  startingInstanceId: Instance["id"];
  instances: Instances;
  props: Props;
  dataSources: DataSources;
  resources: Resources;
}) => {
  const unsetVariables = new Set<DataSource["name"]>();
  traverseExpressions({
    startingInstanceId: undefined,
    pages: undefined,
    instances,
    props,
    dataSources,
    resources,
    update: (expression, _instanceId, args = []) => {
      transpileExpression({
        expression,
        replaceVariable: (identifier) => {
          const id = decodeDataVariableId(identifier);
          if (id === undefined && args.includes(identifier) === false) {
            unsetVariables.add(decodeDataVariableName(identifier));
          }
        },
      });
    },
  });
  return Array.from(unsetVariables);
};

export const findUsedVariables = ({
  startingInstanceId,
  pages,
  instances,
  props,
  dataSources,
  resources,
}: {
  startingInstanceId: Instance["id"];
  pages: undefined | Pages;
  instances: Instances;
  props: Props;
  dataSources: DataSources;
  resources: Resources;
}) => {
  const usedVariables = new Map<DataSource["id"], number>();
  traverseExpressions({
    startingInstanceId,
    pages,
    instances,
    props,
    dataSources,
    resources,
    update: (expression) => {
      const identifiers = getExpressionIdentifiers(expression);
      for (const identifier of identifiers) {
        const id = decodeDataVariableId(identifier);
        if (id !== undefined) {
          const count = usedVariables.get(id) ?? 0;
          usedVariables.set(id, count + 1);
        }
      }
    },
  });
  return usedVariables;
};

export const findVariableUsagesByInstance = ({
  startingInstanceId,
  pages,
  instances,
  props,
  dataSources,
  resources,
}: {
  startingInstanceId: Instance["id"];
  pages: undefined | Pages;
  instances: Instances;
  props: Props;
  dataSources: DataSources;
  resources: Resources;
}) => {
  const usedIn = new Map<DataSource["id"], Set<Instance["id"]>>();
  traverseExpressions({
    startingInstanceId,
    pages,
    instances,
    props,
    dataSources,
    resources,
    update: (expression, instanceId) => {
      const identifiers = getExpressionIdentifiers(expression);
      for (const identifier of identifiers) {
        const id = decodeDataVariableId(identifier);
        if (id !== undefined) {
          if (!usedIn.has(id)) {
            usedIn.set(id, new Set());
          }
          usedIn.get(id)?.add(instanceId);
        }
      }
    },
  });
  return usedIn;
};

export const rebindTreeVariablesMutable = ({
  startingInstanceId,
  pages,
  instances,
  props,
  dataSources,
  resources,
}: {
  startingInstanceId: Instance["id"];
  pages: undefined | Pages;
  instances: Instances;
  props: Props;
  dataSources: DataSources;
  resources: Resources;
}) => {
  const unsetNameById = new Map<DataSource["id"], DataSource["name"]>();
  for (const dataSource of dataSources.values()) {
    unsetNameById.set(dataSource.id, dataSource.name);
  }
  const parentInstanceById = getParentInstanceById(instances);
  const dataSourcesByScopeInstanceId =
    getDataSourcesByScopeInstanceId(dataSources);
  traverseExpressions({
    startingInstanceId,
    pages,
    instances,
    props,
    dataSources,
    resources,
    update: (expression, instanceId, args) => {
      const { maskedIdByName: maskedVariables } = findVariablesByInstanceId({
        startingInstanceId: instanceId,
        parentInstanceById,
        instances,
        dataSources,
        dataSourcesByScopeInstanceId,
      });
      const maskedIdByName = new Map(maskedVariables);
      if (args) {
        for (const arg of args) {
          maskedIdByName.delete(arg);
        }
      }
      expression = unsetExpressionVariables({
        expression,
        unsetNameById,
      });
      expression = restoreExpressionVariables({
        expression,
        maskedIdByName,
      });
      return expression;
    },
  });
};

const removeFormActionsForResources = <T extends { dataSourceId: string }>(
  actions: T[],
  removedIds: ReadonlySet<string>
): T[] => actions.filter((action) => !removedIds.has(action.dataSourceId));

export const deleteVariableMutable = (
  data: Pick<
    BuilderState,
    "instances" | "props" | "dataSources" | "resources"
  > & {
    pages?: Pages;
  },
  variableId: DataSource["id"]
) => {
  if (
    data.instances === undefined ||
    data.props === undefined ||
    data.dataSources === undefined ||
    data.resources === undefined
  ) {
    return;
  }
  const dataSource = data.dataSources.get(variableId);
  if (dataSource === undefined) {
    return;
  }
  data.dataSources.delete(variableId);
  const removedIds = new Set([variableId]);
  for (const prop of data.props.values()) {
    if (
      prop.type !== "json" ||
      prop.name !== "action" ||
      data.instances.get(prop.instanceId)?.component !== "ResourceForm" ||
      !isFormSubmission(prop.value) ||
      !prop.value.some((action) => action.dataSourceId === variableId)
    ) {
      continue;
    }
    prop.value = removeFormActionsForResources(prop.value, removedIds);
  }
  if (dataSource.type === "resource") {
    data.resources.delete(dataSource.resourceId);
  }
  if (data.pages !== undefined) {
    for (const page of data.pages.pages.values()) {
      if (page.systemDataSourceId === variableId) {
        delete page.systemDataSourceId;
      }
    }
    for (const template of data.pages.pageTemplates?.values() ?? []) {
      if (template.systemDataSourceId === variableId) {
        delete template.systemDataSourceId;
      }
    }
  }
  const unsetNameById = new Map<DataSource["id"], DataSource["name"]>();
  unsetNameById.set(dataSource.id, dataSource.name);
  const startingInstanceId = dataSource.scopeInstanceId ?? ROOT_INSTANCE_ID;
  const { maskedIdByName } = findVariablesByInstanceId({
    startingInstanceId,
    parentInstanceById: getParentInstanceById(data.instances),
    instances: data.instances,
    dataSources: data.dataSources,
    dataSourcesByScopeInstanceId: getDataSourcesByScopeInstanceId(
      data.dataSources
    ),
  });
  traverseExpressions({
    instances: data.instances,
    props: data.props,
    dataSources: data.dataSources,
    resources: data.resources,
    pages: data.pages,
    startingInstanceId,
    update: (expression) => {
      expression = unsetExpressionVariables({
        expression,
        unsetNameById,
      });
      expression = restoreExpressionVariables({
        expression,
        maskedIdByName,
      });
      return expression;
    },
  });
};

export const createTreeVariableRebindPayload = ({
  startingInstanceId,
  startingInstanceIds,
  pages,
  instances,
  props,
  dataSources,
  resources,
}: Pick<
  BuilderState,
  "pages" | "instances" | "props" | "dataSources" | "resources"
> & {
  startingInstanceId?: Instance["id"];
  startingInstanceIds?: Instance["id"][];
}) => {
  if (
    instances === undefined ||
    props === undefined ||
    dataSources === undefined ||
    resources === undefined
  ) {
    return [];
  }
  if (dataSources.size === 0) {
    return [];
  }
  const instanceIds =
    startingInstanceIds ??
    (startingInstanceId === undefined ? [] : [startingInstanceId]);
  return produceWebstudioDataMutation(
    { pages, instances, props, dataSources, resources },
    (draft) => {
      for (const instanceId of instanceIds) {
        rebindTreeVariablesMutable({
          startingInstanceId: instanceId,
          ...draft,
        });
      }
    }
  ).payload;
};

export const createDataVariableDeletePayload = ({
  variableId,
  pages,
  instances,
  props,
  dataSources,
  resources,
}: Pick<BuilderState, "instances" | "props" | "dataSources" | "resources"> & {
  pages?: Pages;
  variableId: DataSource["id"];
}): {
  payload: BuilderPatchChange[];
  deletedVariable?: DataSource;
} => {
  if (
    instances === undefined ||
    props === undefined ||
    dataSources === undefined ||
    resources === undefined
  ) {
    return { payload: [] };
  }
  const deletedVariable = dataSources.get(variableId);
  if (deletedVariable === undefined) {
    return { payload: [] };
  }

  const { payload } = produceWebstudioDataMutation(
    { pages, instances, props, dataSources, resources },
    (draft) => {
      deleteVariableMutable(draft, variableId);
    }
  );
  return { payload, deletedVariable };
};

export const findUnusedDataVariableIds = ({
  pages,
  instances,
  props,
  dataSources,
  resources,
}: {
  pages: undefined | Pages;
  instances: Instances;
  props: Props;
  dataSources: DataSources;
  resources: Resources;
}) => {
  const usedVariables = findVariableUsagesByInstance({
    startingInstanceId: ROOT_INSTANCE_ID,
    pages,
    instances,
    props,
    dataSources,
    resources,
  });
  const variableIds: DataSource["id"][] = [];
  for (const dataSource of dataSources.values()) {
    if (dataSource.type !== "variable") {
      continue;
    }
    const usages = usedVariables.get(dataSource.id);
    if (usages === undefined || usages.size === 0) {
      variableIds.push(dataSource.id);
    }
  }
  return variableIds;
};

export const createUnusedDataVariablesDeletePayload = ({
  pages,
  instances,
  props,
  dataSources,
  resources,
}: Pick<BuilderState, "instances" | "props" | "dataSources" | "resources"> & {
  pages?: Pages;
}): {
  payload: BuilderPatchChange[];
  deletedVariableIds: DataSource["id"][];
} => {
  if (
    instances === undefined ||
    props === undefined ||
    dataSources === undefined ||
    resources === undefined
  ) {
    return { payload: [], deletedVariableIds: [] };
  }
  const deletedVariableIds = findUnusedDataVariableIds({
    pages,
    instances,
    props,
    dataSources,
    resources,
  });
  if (deletedVariableIds.length === 0) {
    return { payload: [], deletedVariableIds };
  }

  const { payload } = produceWebstudioDataMutation(
    { pages, instances, props, dataSources, resources },
    (draft) => {
      for (const variableId of deletedVariableIds) {
        deleteVariableMutable(draft, variableId);
      }
    }
  );
  return {
    payload,
    deletedVariableIds,
  };
};

const createDataVariableValue = ({
  dataSourceId,
  scopeInstanceId,
  name,
  value,
}: {
  dataSourceId: DataSource["id"];
  scopeInstanceId: Instance["id"];
  name: DataSource["name"];
  value: DataVariable["value"];
}): DataVariable => ({
  id: dataSourceId,
  scopeInstanceId,
  name,
  type: "variable",
  value,
});

export const createDataVariableCreatePayload = ({
  dataSourceId,
  scopeInstanceId,
  name,
  value,
  dataSources,
}: {
  dataSourceId: DataSource["id"];
  scopeInstanceId: Instance["id"];
  name: DataSource["name"];
  value: DataVariable["value"];
  dataSources: Iterable<DataSource>;
}) => {
  const dataSourceList = Array.from(dataSources);
  const errors = [];
  for (const dataSource of dataSourceList) {
    if (dataSource.id === dataSourceId) {
      errors.push({ type: "duplicate-id" as const, dataSourceId });
      break;
    }
  }
  const nameError = validateDataVariableNameWithSources({
    dataSources: dataSourceList,
    name,
    variableId: dataSourceId,
    scopeInstanceId,
  });
  if (nameError) {
    errors.push(nameError);
  }
  if (errors.length > 0) {
    return { payload: [], errors };
  }
  return {
    payload: [
      {
        namespace: "dataSources" as const,
        patches: [
          {
            op: "add" as const,
            path: [dataSourceId],
            value: createDataVariableValue({
              dataSourceId,
              scopeInstanceId,
              name,
              value,
            }),
          },
        ],
      },
    ],
    errors,
  };
};

const createDataSourceUpsertPayload = ({
  pages,
  instances,
  props,
  dataSources,
  resources,
  dataSource,
}: Pick<
  BuilderState,
  "pages" | "instances" | "props" | "dataSources" | "resources"
> & {
  dataSource: DataSource;
}) => {
  if (
    instances === undefined ||
    props === undefined ||
    dataSources === undefined ||
    resources === undefined
  ) {
    return [];
  }
  if (dataSource.scopeInstanceId === undefined) {
    return [];
  }
  const scopeInstanceId = dataSource.scopeInstanceId;
  return produceWebstudioDataMutation(
    { pages, instances, props, dataSources, resources },
    (draft) => {
      if (dataSource.type === "variable") {
        const previous = draft.dataSources.get(dataSource.id);
        if (previous?.type === "resource") {
          draft.resources.delete(previous.resourceId);
        }
      }
      draft.dataSources.set(dataSource.id, dataSource);
      rebindTreeVariablesMutable({
        startingInstanceId: scopeInstanceId,
        ...draft,
      });
    }
  ).payload;
};

export const createDataVariableUpdatePayload = ({
  variable,
  values,
  dataSources,
}: {
  variable: Pick<DataSource, "id" | "name" | "scopeInstanceId">;
  values: Partial<Pick<DataVariable, "scopeInstanceId" | "name" | "value">>;
  dataSources: Iterable<DataSource>;
}) => {
  if (values.name !== undefined || values.scopeInstanceId !== undefined) {
    const error = validateDataVariableNameWithSources({
      dataSources,
      name: values.name ?? variable.name,
      variableId: variable.id,
      scopeInstanceId: values.scopeInstanceId ?? variable.scopeInstanceId,
    });
    if (error) {
      return { payload: [], error };
    }
  }
  return {
    payload: compactBuilderPatchPayload([
      {
        namespace: "dataSources",
        patches: Object.entries(values).flatMap(([name, value]) =>
          value === undefined
            ? []
            : [{ op: "replace" as const, path: [variable.id, name], value }]
        ),
      },
    ]),
  };
};

export const createDataVariable = (
  state: Pick<
    BuilderState,
    "pages" | "instances" | "props" | "dataSources" | "resources"
  >,
  input: z.infer<typeof dataVariableCreateInput>,
  context: BuilderRuntimeContext
) => {
  const dataSources = getRequiredDataSources(state);
  const dataSourceId = context.createId();
  const { payload, errors } = createDataVariableCreatePayload({
    dataSourceId,
    scopeInstanceId: input.scopeInstanceId,
    name: input.name,
    value: input.value,
    dataSources: dataSources.values(),
  });
  const error = errors.at(0);
  if (error?.type === "duplicate-id") {
    return throwBuilderRuntimeError("CONFLICT", "Variable id already exists");
  }
  if (error) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "message" in error ? error.message : "Invalid variable"
    );
  }
  const variable = createDataVariableValue({
    dataSourceId,
    scopeInstanceId: input.scopeInstanceId,
    name: input.name,
    value: input.value,
  });
  return createRuntimeMutation({
    payload:
      createDataSourceUpsertPayload({
        ...state,
        dataSource: variable,
      }) ?? payload,
    result: { dataSourceId },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
    ],
  });
};

export const isManagedFormParameter = (
  dataSource: DataSource | undefined,
  instances: BuilderState["instances"]
) =>
  dataSource?.type === "parameter" &&
  (dataSource.name === formDataParameterName ||
    dataSource.name === browserInfoParameterName) &&
  instances?.get(dataSource.scopeInstanceId ?? "")?.component ===
    "ResourceForm";

export const isRequiredManagedFormVariable = (
  dataSource: DataSource | undefined,
  state: Pick<BuilderState, "instances" | "props">
) => {
  const dataSourceId = dataSource?.id;
  const scopeInstanceId = dataSource?.scopeInstanceId;
  if (
    dataSourceId === undefined ||
    scopeInstanceId === undefined ||
    state.instances?.get(scopeInstanceId)?.component !== "ResourceForm"
  ) {
    return false;
  }
  const requiredPropNames = new Set([
    "state",
    "onStateChange",
    "onProgressChange",
    "onResultChange",
  ]);
  const dataSourceReferences = /\$ws\$dataSource\$[\w$]+/g;
  return [...(state.props?.values() ?? [])].some((prop) => {
    if (
      prop.instanceId !== scopeInstanceId ||
      !requiredPropNames.has(prop.name)
    ) {
      return false;
    }
    return [...JSON.stringify(prop.value).matchAll(dataSourceReferences)].some(
      ([reference]) => decodeDataSourceVariable(reference) === dataSourceId
    );
  });
};

export const updateDataVariable = (
  state: Pick<
    BuilderState,
    "pages" | "instances" | "props" | "dataSources" | "resources"
  >,
  input: z.infer<typeof dataVariableUpdateInput>
) => {
  const dataSources = getRequiredDataSources(state);
  const dataSource = dataSources.get(input.dataSourceId);
  if (dataSource === undefined) {
    return throwBuilderRuntimeError("NOT_FOUND", "Variable not found");
  }
  if (isManagedFormParameter(dataSource, state.instances)) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Form submission variables cannot be edited"
    );
  }
  const scopeInstanceId =
    input.values.scopeInstanceId ?? dataSource.scopeInstanceId;
  if (scopeInstanceId === undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Variable scope instance is required"
    );
  }
  const { error, payload } = createDataVariableUpdatePayload({
    variable: dataSource,
    values: input.values,
    dataSources: dataSources.values(),
  });
  if (error) {
    return throwBuilderRuntimeError("BAD_REQUEST", error.message);
  }
  const { value, ...metadataValues } = input.values;
  if (
    dataSource.type === "resource" &&
    value === undefined &&
    (metadataValues.scopeInstanceId === undefined ||
      metadataValues.scopeInstanceId === dataSource.scopeInstanceId)
  ) {
    return createRuntimeMutation({
      payload,
      result: { dataSourceId: dataSource.id },
      invalidatesNamespaces: ["dataSources"],
    });
  }
  const nextDataSource =
    dataSource.type === "resource" && value !== undefined
      ? {
          ...createDataVariableValue({
            dataSourceId: dataSource.id,
            scopeInstanceId,
            name: dataSource.name,
            value,
          }),
          ...metadataValues,
        }
      : {
          ...dataSource,
          ...metadataValues,
          ...(value === undefined ? {} : { value }),
        };
  return createRuntimeMutation({
    payload: createDataSourceUpsertPayload({
      ...state,
      dataSource: nextDataSource,
    }),
    result: { dataSourceId: nextDataSource.id },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
    ],
  });
};

export const deleteDataVariable = (
  state: Pick<
    BuilderState,
    "pages" | "instances" | "props" | "dataSources" | "resources"
  >,
  input: z.infer<typeof dataVariableDeleteInput>
) => {
  const dataSource = state.dataSources?.get(input.dataSourceId);
  if (
    isManagedFormParameter(dataSource, state.instances) ||
    isRequiredManagedFormVariable(dataSource, state)
  ) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Form submission variables cannot be deleted"
    );
  }
  const { payload, deletedVariable } = createDataVariableDeletePayload({
    variableId: input.dataSourceId,
    pages: state.pages,
    instances: state.instances,
    props: state.props,
    dataSources: state.dataSources,
    resources: state.resources,
  });
  if (deletedVariable === undefined) {
    return throwBuilderRuntimeError("NOT_FOUND", "Variable not found");
  }
  return createRuntimeMutation({
    payload,
    result: { dataSourceId: deletedVariable.id },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
    ],
  });
};

export const deleteUnusedDataVariables = (
  state: Pick<
    BuilderState,
    "pages" | "instances" | "props" | "dataSources" | "resources"
  >,
  _input: z.infer<typeof dataVariableDeleteUnusedInput>
) => {
  const { payload, deletedVariableIds } =
    createUnusedDataVariablesDeletePayload({
      pages: state.pages,
      instances: state.instances,
      props: state.props,
      dataSources: state.dataSources,
      resources: state.resources,
    });
  return createRuntimeMutation({
    payload,
    result: {
      dataSourceIds: deletedVariableIds,
      deletedCount: deletedVariableIds.length,
    },
    invalidatesNamespaces:
      deletedVariableIds.length === 0
        ? []
        : ["pages", "instances", "props", "dataSources", "resources"],
  });
};

export const findResource = (
  resources: Iterable<Resource>,
  resourceId: Resource["id"]
) => {
  for (const value of resources) {
    if (value.id === resourceId) {
      return value;
    }
  }
};

const addExpressionIssues = (
  context: z.RefinementCtx,
  issues: readonly SemanticValidationIssue[]
) => {
  for (const issue of issues) {
    addZodValidationIssue(
      context,
      issue,
      issue.code === "invalid_resource_url"
        ? { message: `${issue.path.join(".")}: ${issue.message}` }
        : undefined
    );
  }
};

const resourceUrlLiteralPattern = /^(?:[A-Za-z][A-Za-z0-9+.-]*:\/\/|\/)/;
const resourceExpressionStartPattern = /^\s*(?:["'`[{(]|(?:await|new)\b)/;

const normalizeResourceUrlInput = (value: string) => {
  if (
    resourceUrlLiteralPattern.test(value) &&
    resourceExpressionStartPattern.test(value) === false
  ) {
    return JSON.stringify(value);
  }
  return value;
};

export const resourceExpressionInput = z
  .union([
    z.string(),
    z.object({ type: z.literal("literal"), value: z.string() }),
  ])
  .describe(
    'One dynamic Webstudio JavaScript expression, or { type: "literal", value: string } for fixed text. Read webstudio://project/expressions for syntax, scope, resource-result shape, and supported methods.'
  );

const resourceExpressionEntryInput = z.object({
  name: z.string(),
  value: resourceExpressionInput,
});

const resourceFieldsInputBase = resource
  .omit({ id: true })
  .extend({
    control: z.enum(["system", "graphql", "email"]).optional(),
    url: z.preprocess(
      (value) =>
        typeof value === "string" ? normalizeResourceUrlInput(value) : value,
      z.string()
    ),
    searchParams: z.array(resourceExpressionEntryInput).optional(),
    headers: z.array(resourceExpressionEntryInput),
    body: resourceExpressionInput.optional(),
  })
  .strict();

const addEmailResourceIssues = (
  fields: { control?: Resource["control"]; email?: Resource["email"] },
  context: z.RefinementCtx,
  allowPartial = false
) => {
  if (fields.control !== "email") {
    if (
      fields.email !== undefined &&
      (!allowPartial || fields.control !== undefined)
    ) {
      context.addIssue({
        code: "custom",
        path: ["email"],
        message: "Email settings require an Email Resource.",
      });
    }
    if (fields.email === undefined) {
      return;
    }
  }
  const settings = fields.email;
  if (
    !allowPartial &&
    settings?.recipientMode === "custom" &&
    settings.recipientsExpression === undefined &&
    (!settings.recipients || validateContactEmail(settings.recipients))
  ) {
    context.addIssue({
      code: "custom",
      path: ["email", "recipients"],
      message: "Enter a valid recipient list.",
    });
  }
  if (
    !allowPartial &&
    settings?.sender !== undefined &&
    settings.senderExpression === undefined &&
    (settings.sender === "" || validateEmailSender(settings.sender))
  ) {
    context.addIssue({
      code: "custom",
      path: ["email", "sender"],
      message: "Reply to must contain exactly one valid email address.",
    });
  }
};

const emailSettingsInput = resourceFieldsInputBase
  .pick({ control: true, email: true })
  .superRefine(addEmailResourceIssues);

export const resourceFieldsInput = resourceFieldsInputBase.superRefine(
  (fields, context) => {
    addEmailResourceIssues(fields, context);
    const normalizedFields = normalizeResourceFieldsInput(fields);
    addExpressionIssues(
      context,
      getResourceExpressionValidationIssues(normalizedFields)
    );
    addExpressionIssues(
      context,
      getResourceLiteralUrlValidationIssues(
        fields.control === "email" ? {} : normalizedFields
      )
    );
  }
);

export const resourceFieldsUpdateInput = resourceFieldsInputBase
  .partial()
  .superRefine((fields, context) => {
    addEmailResourceIssues(fields, context, true);
    const normalizedFields = normalizeResourceFieldsUpdateInput(fields);
    addExpressionIssues(
      context,
      getResourceExpressionValidationIssues(normalizedFields)
    );
    addExpressionIssues(
      context,
      getResourceLiteralUrlValidationIssues(
        fields.control === "email" ? {} : normalizedFields
      )
    );
  });

export const normalizeResourceExpressionInput = (
  value: string | { type: "literal"; value: unknown }
) => (typeof value === "string" ? value : JSON.stringify(value.value));

type ResourceFields = Omit<Resource, "id">;
type ResourceFieldsUpdate = Partial<ResourceFields>;

const normalizeResourceFields = (
  fields: z.infer<typeof resourceFieldsUpdateInput>
): ResourceFieldsUpdate => {
  const { searchParams, headers, body, ...scalarFields } = fields;
  return {
    ...scalarFields,
    ...(fields.searchParams === undefined
      ? {}
      : {
          searchParams: fields.searchParams.map((entry) => ({
            name: entry.name,
            value: normalizeResourceExpressionInput(entry.value),
          })),
        }),
    ...(fields.headers === undefined
      ? {}
      : {
          headers: fields.headers.map((entry) => ({
            name: entry.name,
            value: normalizeResourceExpressionInput(entry.value),
          })),
        }),
    ...(fields.body === undefined
      ? {}
      : { body: normalizeResourceExpressionInput(fields.body) }),
  };
};

const normalizeResourceFieldsInput = (
  fields: z.infer<typeof resourceFieldsInput>
): ResourceFields => normalizeResourceFields(fields) as ResourceFields;

const normalizeResourceFieldsUpdateInput = normalizeResourceFields;

const exposeAsDataSourceInput = z
  .boolean()
  .optional()
  .describe(
    "Expose the resource as render-time data. Scoped GET resources default to true; write resources default to false."
  );

export const resourceCreateInput = z
  .object({
    resourceId: runtimeGeneratedIdInput,
    resource: resourceFieldsInput,
    dataSourceId: runtimeGeneratedIdInput,
    scopeInstanceId: optionalResourceScopeInstanceIdInput,
    dataSourceName: z.string().optional(),
    exposeAsDataSource: exposeAsDataSourceInput,
  })
  .superRefine((input, context) => {
    if (
      input.exposeAsDataSource === true &&
      input.scopeInstanceId === undefined
    ) {
      addZodValidationIssue(context, {
        code: "missing_resource_scope",
        path: ["scopeInstanceId"],
        message: "scopeInstanceId is required when exposeAsDataSource is true.",
        constraint: "required_when:exposeAsDataSource=true",
        example: "instance-id",
      });
    }
  });

export const resourceUpdateInput = z.object({
  resourceId: z.string(),
  values: resourceFieldsUpdateInput,
  dataSourceName: z.string().optional(),
  scopeInstanceId: optionalResourceScopeInstanceIdInput,
  exposeAsDataSource: exposeAsDataSourceInput,
});

export const replaceResourceTextInput = z.object({
  find: z.string().min(1).describe("Fixed resource text to find."),
  replace: z.string().describe("Replacement fixed resource text."),
  match: z
    .enum(["exact", "substring"])
    .default("exact")
    .describe(
      'Use "exact" to replace complete values, or "substring" to replace every literal occurrence in matching values.'
    ),
  fields: z
    .array(z.enum(["name", "url"]))
    .min(1)
    .default(["name", "url"])
    .describe("Resource text fields to replace."),
  resourceIds: z
    .array(z.string())
    .min(1)
    .optional()
    .describe("Optional resource ids to limit scope."),
  limit: z
    .number()
    .int()
    .min(1)
    .max(200)
    .default(50)
    .describe("Maximum number of resource fields to change."),
});

export const resourceUpsertInput = z.object({
  resourceId: z.string().optional(),
  resource: resourceFieldsInput,
  dataSourceId: z.string().optional(),
  scopeInstanceId: z.string(),
  dataSourceName: z.string().optional(),
});

export const resourcePropUpsertInput = z.object({
  instanceId: z.string(),
  propName: z.string(),
  resourceId: z.string().optional(),
  resource: resourceFieldsInput,
  scopeInstanceId: z.string().optional(),
  dataSourceName: z.string().optional(),
});

export const resourceDeleteInput = z.object({
  resourceId: z.string(),
  force: z.boolean().optional(),
});

type ResourceFormData = {
  get(name: string): unknown;
  getAll(name: string): unknown[];
};

export const createResourceFieldsFromFormData = ({
  control,
  name,
  formData,
}: {
  control?: string;
  name?: string;
  formData: ResourceFormData;
}): z.infer<typeof resourceFieldsInput> => {
  const searchParamNames = formData.getAll("search-param-name");
  const searchParamValues = formData.getAll("search-param-value");
  const headerNames = formData.getAll("header-name");
  const headerValues = formData.getAll("header-value");
  return resourceFieldsInput.parse({
    control,
    name: name ?? formData.get("name"),
    url: formData.get("url"),
    searchParams: searchParamNames
      .map((name, index) => ({ name, value: searchParamValues[index] }))
      .filter((item) => String(item.name).trim()),
    method: formData.get("method"),
    headers: headerNames
      .map((name, index) => ({ name, value: headerValues[index] }))
      .filter((item) => String(item.name).trim()),
    body: formData.get("body") || undefined,
    ...(formData.get("body-format")
      ? { bodyFormat: formData.get("body-format") }
      : {}),
    ...(control === "email"
      ? { email: JSON.parse(String(formData.get("email-settings") ?? "{}")) }
      : {}),
  });
};

export const createResourceValueFromFormData = ({
  id,
  control,
  name,
  formData,
}: {
  id: Resource["id"];
  control?: string;
  name?: string;
  formData: ResourceFormData;
}): Resource =>
  createResourceValue({
    id,
    ...normalizeResourceFieldsInput(
      createResourceFieldsFromFormData({ control, name, formData })
    ),
  });

export const createResourceValue = ({
  id,
  control,
  name,
  url,
  searchParams,
  method,
  headers,
  body,
  bodyFormat,
  email,
}: {
  id: Resource["id"];
  control?: unknown;
  name?: unknown;
  url: unknown;
  searchParams?: unknown;
  method: unknown;
  headers: unknown;
  body?: unknown;
  bodyFormat?: unknown;
  email?: unknown;
}): Resource =>
  resource.parse({
    id,
    control,
    name,
    url,
    searchParams,
    method,
    headers,
    body: body || undefined,
    ...(bodyFormat === undefined ? {} : { bodyFormat }),
    ...(email === undefined ? {} : { email }),
  });

export const createResourceFieldsFromResource = (
  resource: Resource
): z.infer<typeof resourceFieldsInput> => ({
  name: resource.name,
  control: resource.control,
  url: resource.url,
  searchParams: resource.searchParams,
  method: resource.method,
  headers: resource.headers,
  body: resource.body,
  ...(resource.bodyFormat === undefined
    ? {}
    : { bodyFormat: resource.bodyFormat }),
  ...(resource.email === undefined ? {} : { email: resource.email }),
});

export const validateResourceUrlExpression = async (
  expression: string,
  scope: Record<string, unknown>
) => {
  const value = await computeExpressionWithinScope(expression, scope);
  if (typeof value !== "string") {
    return "URL expects a string";
  }
  if (value.length === 0) {
    return "URL is required";
  }
  try {
    new URL(value);
  } catch {
    return "URL is invalid";
  }
  return "";
};

export type ResourceBodyInputType = undefined | "text" | "json";

export const validateResourceBodyExpression = async (
  expression: string,
  bodyType: ResourceBodyInputType,
  scope: Record<string, unknown>
) => {
  if (expression === "") {
    return "";
  }
  const value = await computeExpressionWithinScope(expression, scope);
  if (bodyType === "json") {
    return typeof value === "object" && value !== null
      ? ""
      : "Expected valid JSON object in body";
  }
  return typeof value === "string" ? "" : "Expected string in body";
};

type ResourceExpressionFields = Partial<
  Pick<Resource, "url" | "body" | "headers" | "searchParams" | "email">
>;

export const listResourceExpressions = (
  fields: ResourceExpressionFields,
  pathPrefix: string[] = []
) => [
  ...(fields.url === undefined
    ? []
    : [{ path: [...pathPrefix, "url"], expression: fields.url }]),
  ...(fields.body === undefined
    ? []
    : [{ path: [...pathPrefix, "body"], expression: fields.body }]),
  ...(fields.email?.subject === undefined
    ? []
    : [
        {
          path: [...pathPrefix, "email", "subject"],
          expression: fields.email.subject,
        },
      ]),
  ...(fields.email?.senderExpression === undefined
    ? []
    : [
        {
          path: [...pathPrefix, "email", "senderExpression"],
          expression: fields.email.senderExpression,
        },
      ]),
  ...(fields.email?.recipientsExpression === undefined
    ? []
    : [
        {
          path: [...pathPrefix, "email", "recipientsExpression"],
          expression: fields.email.recipientsExpression,
        },
      ]),
  ...(fields.email?.body === undefined
    ? []
    : [
        {
          path: [...pathPrefix, "email", "body"],
          expression: fields.email.body,
        },
      ]),
  ...(fields.headers ?? []).map((header, index) => ({
    path: [...pathPrefix, "headers", String(index), "value"],
    expression: header.value,
  })),
  ...(fields.searchParams ?? []).map((param, index) => ({
    path: [...pathPrefix, "searchParams", String(index), "value"],
    expression: param.value,
  })),
];

const getResourceExpressionValidationIssues = (
  fields: ResourceExpressionFields
): SemanticValidationIssue[] =>
  listResourceExpressions(fields).flatMap(({ path, expression }) =>
    getNamedExpressionValidationIssues(path.join("."), expression)
  );

const getResourceWarnings = ({
  fields,
  state,
  scopeInstanceId,
  resourceId,
  exposeAsDataSource = false,
  fieldPath = ["resource"],
  methodPath = ["resource", "method"],
}: {
  fields: Pick<
    Resource,
    "control" | "method" | "url" | "body" | "headers" | "searchParams" | "email"
  >;
  state: Pick<BuilderState, "instances" | "dataSources">;
  scopeInstanceId?: string;
  resourceId: string;
  exposeAsDataSource?: boolean;
  fieldPath?: string[];
  methodPath?: string[];
}) => {
  const availableVariables = new Set(
    scopeInstanceId === undefined ||
      state.instances === undefined ||
      state.dataSources === undefined
      ? ["system"]
      : findAvailableVariables({
          startingInstanceId: scopeInstanceId,
          instances: state.instances,
          dataSources: state.dataSources,
        }).map(({ name }) => name)
  );
  const warnings = listResourceExpressions(fields, fieldPath).flatMap(
    ({ path, expression }) =>
      getExpressionWarnings({
        expression,
        availableVariables,
        path,
        resourceId,
      })
  );
  const isRenderTimeRead = fields.method === "get" || isAssetsResource(fields);
  if (exposeAsDataSource && isRenderTimeRead === false) {
    warnings.push({
      severity: "warning",
      code: "render_time_mutation_resource",
      path: methodPath,
      message: `The ${fields.method.toUpperCase()} resource is explicitly exposed as render-time data and may execute while rendering the page.`,
      range: { from: 0, to: 0 },
      remediation:
        "Expose GET resources for render-time data, or trigger mutating resources from an explicit action.",
      resourceId,
    });
  }
  return warnings;
};

export const getResourceExpressionErrors = (
  fields: Partial<
    Pick<Resource, "url" | "body" | "headers" | "searchParams" | "email">
  >
) =>
  formatValidationIssueMessages(getResourceExpressionValidationIssues(fields))
    .split("\n")
    .filter(Boolean);

const getResourceLiteralUrlValidationIssues = (
  fields: Partial<Pick<Resource, "url">>
): SemanticValidationIssue[] => {
  if (fields.url === undefined || isLiteralExpression(fields.url) === false) {
    return [];
  }
  let value: unknown;
  try {
    value = JSON.parse(fields.url);
  } catch {
    return [];
  }
  if (typeof value !== "string") {
    return [
      {
        code: "invalid_resource_url",
        path: ["url"],
        message: "URL expects a string",
        constraint: "absolute_or_root_relative_url",
        example: "https://api.example.com/posts",
      },
    ];
  }
  if (value.length === 0) {
    return [
      {
        code: "invalid_resource_url",
        path: ["url"],
        message: "URL is required",
        constraint: "absolute_or_root_relative_url",
        example: "https://api.example.com/posts",
      },
    ];
  }
  try {
    new URL(value);
    return [];
  } catch {
    try {
      const baseUrl = new URL("https://resource.webstudio.invalid");
      const parsedUrl = new URL(value, baseUrl);
      if (
        value.startsWith("/") &&
        value.startsWith("//") === false &&
        parsedUrl.origin === baseUrl.origin
      ) {
        return [];
      }
    } catch {
      // Report the shared URL validation issue below.
    }
  }
  return [
    {
      code: "invalid_resource_url",
      path: ["url"],
      message: "URL is invalid",
      constraint: "absolute_or_root_relative_url",
      example: "https://api.example.com/posts",
    },
  ];
};

const validateResourceFields = (
  fields: Partial<
    Pick<
      Resource,
      "control" | "url" | "body" | "headers" | "searchParams" | "email"
    >
  >,
  pathPrefix: readonly string[] = []
) => {
  const issues = [
    ...getResourceExpressionValidationIssues(fields),
    ...getResourceLiteralUrlValidationIssues(
      fields.control === "email" ? {} : fields
    ),
  ];
  if (issues.length > 0) {
    return throwBuilderValidationError(
      formatValidationIssueMessages(issues),
      prefixValidationIssuePaths(issues, pathPrefix)
    );
  }
};

const validateEmailExpressionBindings = ({
  email,
  scopeInstanceId,
  instances,
  dataSources,
}: {
  email: Resource["email"];
  scopeInstanceId: Instance["id"];
  instances: Instance[];
  dataSources: DataSource[];
}) => {
  if (
    email?.senderExpression === undefined &&
    email?.recipientsExpression === undefined &&
    email?.subject === undefined &&
    email?.body === undefined
  ) {
    return;
  }
  const instancesById = new Map(
    instances.map((instance) => [instance.id, instance])
  );
  const dataSourcesById = new Map(
    dataSources.map((dataSource) => [dataSource.id, dataSource])
  );
  const { maskedIdByName, availableDataSourceIds } = findVariablesByInstanceId({
    startingInstanceId: scopeInstanceId,
    parentInstanceById: getParentInstanceById(instancesById),
    instances: instancesById,
    dataSources: dataSourcesById,
  });
  const availableNames = new Set<string>();
  for (const id of availableDataSourceIds) {
    const dataSource = dataSourcesById.get(id);
    if (isEmailBindingDataSourceAvailable(dataSource)) {
      availableNames.add(encodeDataVariableId(id));
    }
  }
  for (const [name, id] of maskedIdByName) {
    if (isEmailBindingDataSourceAvailable(dataSourcesById.get(id))) {
      availableNames.add(encodeDataVariableName(name));
    }
  }
  const issues = listResourceExpressions({ email }, ["resource"]).flatMap(
    ({ path, expression }) =>
      getExpressionWarnings({
        expression,
        availableVariables: availableNames,
        path,
      }).map(({ message }) => ({
        code: "unavailable_email_resource_binding",
        path,
        message,
        constraint: "available_variable_at_resource_scope",
      }))
  );
  if (issues.length > 0) {
    return throwBuilderValidationError(
      formatValidationIssueMessages(issues),
      issues
    );
  }
};

const validateEmailResourceConsumerBindings = ({
  email,
  resourceId,
  build,
  propInstanceId,
  removedAliasId,
  upsertedAlias,
}: {
  email: Resource["email"];
  resourceId: Resource["id"];
  build: Pick<CompactBuild, "instances" | "props" | "dataSources">;
  propInstanceId?: Instance["id"];
  removedAliasId?: DataSource["id"];
  upsertedAlias?: { id: DataSource["id"]; scopeInstanceId: Instance["id"] };
}) => {
  const scopes = new Set<Instance["id"]>();
  if (propInstanceId !== undefined) {
    scopes.add(propInstanceId);
  }
  for (const prop of build.props) {
    if (prop.type === "resource" && prop.value === resourceId) {
      scopes.add(prop.instanceId);
    }
  }
  for (const dataSource of build.dataSources) {
    if (
      dataSource.type === "resource" &&
      dataSource.resourceId === resourceId &&
      dataSource.id !== removedAliasId &&
      dataSource.id !== upsertedAlias?.id
    ) {
      scopes.add(dataSource.scopeInstanceId ?? ROOT_INSTANCE_ID);
    }
  }
  if (upsertedAlias !== undefined) {
    scopes.add(upsertedAlias.scopeInstanceId);
  }
  if (scopes.size === 0) {
    scopes.add(ROOT_INSTANCE_ID);
  }
  for (const scopeInstanceId of scopes) {
    validateEmailExpressionBindings({
      email,
      scopeInstanceId,
      instances: build.instances,
      dataSources: build.dataSources,
    });
  }
};

const createResourceDataSource = ({
  dataSourceId,
  scopeInstanceId,
  name,
  resourceId,
}: {
  dataSourceId: DataSource["id"];
  scopeInstanceId: Instance["id"];
  name: DataSource["name"];
  resourceId: Resource["id"];
}): DataSource => ({
  id: dataSourceId,
  scopeInstanceId,
  name,
  type: "resource",
  resourceId,
});

const getClonedPair = <Item extends { id: string }>(item: Item) =>
  [item.id, structuredClone(item)] as const;

const getBuildItems = <Item>(items: Item[] | Map<string, Item>) =>
  items instanceof Map ? Array.from(items.values()) : items;

export const createWebstudioDataFromBuild = ({
  build,
  assets = [],
}: {
  build: Pick<
    CompactBuild | WebstudioData,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >;
  assets?: Asset[];
}): WebstudioData => ({
  pages: structuredClone(build.pages),
  assets: new Map(assets.map(getClonedPair)),
  assetFolders: new Map(),
  instances: new Map(getBuildItems(build.instances).map(getClonedPair)),
  props: new Map(getBuildItems(build.props).map(getClonedPair)),
  dataSources: new Map(getBuildItems(build.dataSources).map(getClonedPair)),
  resources: new Map(getBuildItems(build.resources).map(getClonedPair)),
  breakpoints: new Map(getBuildItems(build.breakpoints).map(getClonedPair)),
  styleSources: new Map(getBuildItems(build.styleSources).map(getClonedPair)),
  styleSourceSelections: new Map(
    getBuildItems(build.styleSourceSelections).map((item) => [
      item.instanceId,
      structuredClone(item),
    ])
  ),
  styles: new Map(
    getBuildItems(build.styles).map((item) => [
      getStyleDeclKey(item),
      structuredClone(item),
    ])
  ),
});

export const produceWebstudioDataMutation = <Data extends object>(
  data: Data,
  recipe: (draft: Data) => void
) => {
  const [nextData, patches] = produceWithPatches(data, recipe);
  return {
    data: nextData,
    payload: createBuilderPatchPayloadFromImmerPatches(patches),
  };
};

export const upsertResourceMutable = ({
  data,
  resource,
  dataSourceId,
  scopeInstanceId,
  dataSourceName,
  exposeAsDataSource = scopeInstanceId !== undefined,
}: {
  data: Pick<
    WebstudioData,
    "instances" | "props" | "dataSources" | "resources"
  > & {
    pages: WebstudioData["pages"] | undefined;
  };
  resource: Resource;
  dataSourceId?: DataSource["id"];
  scopeInstanceId?: Instance["id"];
  dataSourceName?: DataSource["name"];
  exposeAsDataSource?: boolean;
}) => {
  data.resources.set(resource.id, resource);
  const previousDataSource = Array.from(data.dataSources.values()).find(
    (dataSource) =>
      dataSource.type === "resource" && dataSource.resourceId === resource.id
  );
  if (previousDataSource !== undefined && exposeAsDataSource === false) {
    data.dataSources.delete(previousDataSource.id);
    if (previousDataSource.scopeInstanceId !== undefined) {
      rebindTreeVariablesMutable({
        startingInstanceId: previousDataSource.scopeInstanceId,
        ...data,
      });
      if (data.pages !== undefined) {
        rebindTreeVariablesMutable({
          startingInstanceId: previousDataSource.scopeInstanceId,
          ...data,
          pages: undefined,
        });
      }
    }
  }
  if (
    exposeAsDataSource &&
    dataSourceId !== undefined &&
    scopeInstanceId !== undefined
  ) {
    data.dataSources.set(
      dataSourceId,
      createResourceDataSource({
        dataSourceId,
        scopeInstanceId,
        name: dataSourceName ?? resource.name,
        resourceId: resource.id,
      })
    );
    rebindTreeVariablesMutable({
      startingInstanceId: scopeInstanceId,
      ...data,
    });
    if (data.pages !== undefined) {
      rebindTreeVariablesMutable({
        startingInstanceId: scopeInstanceId,
        ...data,
        pages: undefined,
      });
    }
  }
};

export const createResourceUpsertPatchPayload = ({
  build,
  resource,
  dataSourceId,
  scopeInstanceId,
  dataSourceName,
  exposeAsDataSource,
}: {
  build: Pick<
    CompactBuild,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >;
  resource: Resource;
  dataSourceId?: DataSource["id"];
  scopeInstanceId?: Instance["id"];
  dataSourceName?: DataSource["name"];
  exposeAsDataSource?: boolean;
}) => {
  const before = createWebstudioDataFromBuild({ build });
  return produceWebstudioDataMutation(before, (draft) => {
    upsertResourceMutable({
      data: draft,
      resource,
      dataSourceId,
      scopeInstanceId,
      dataSourceName,
      exposeAsDataSource,
    });
  }).payload;
};

export const createResourceCreatePayload = ({
  resourceId,
  resource: resourceInput,
  resources,
  dataSources,
  dataSourceId,
  scopeInstanceId,
  dataSourceName,
}: {
  resourceId: Resource["id"];
  resource: ResourceFields;
  resources: Iterable<Resource>;
  dataSources: Iterable<DataSource>;
  dataSourceId?: DataSource["id"];
  scopeInstanceId?: DataSource["scopeInstanceId"];
  dataSourceName?: DataSource["name"];
}): {
  payload: BuilderPatchChange[];
  dataSourceId?: DataSource["id"];
  errors: Array<
    | { type: "duplicate-resource-id"; resourceId: Resource["id"] }
    | { type: "duplicate-data-source-id"; dataSourceId: DataSource["id"] }
  >;
} => {
  const errors = [];
  if (Array.from(resources).some((resource) => resource.id === resourceId)) {
    errors.push({ type: "duplicate-resource-id" as const, resourceId });
  }
  const nextDataSourceId =
    scopeInstanceId === undefined ? undefined : dataSourceId;
  if (
    nextDataSourceId !== undefined &&
    Array.from(dataSources).some(
      (dataSource) => dataSource.id === nextDataSourceId
    )
  ) {
    errors.push({
      type: "duplicate-data-source-id" as const,
      dataSourceId: nextDataSourceId,
    });
  }
  if (errors.length > 0) {
    return { payload: [], dataSourceId: nextDataSourceId, errors };
  }

  const payload: BuilderPatchChange[] = [
    {
      namespace: "resources",
      patches: [
        {
          op: "add",
          path: [resourceId],
          value: createResourceValue({
            id: resourceId,
            name: resourceInput.name,
            control: resourceInput.control,
            method: resourceInput.method,
            url: resourceInput.url,
            searchParams: resourceInput.searchParams,
            headers: resourceInput.headers,
            body: resourceInput.body,
            bodyFormat: resourceInput.bodyFormat,
            email: resourceInput.email,
          }),
        },
      ],
    },
  ];
  if (nextDataSourceId !== undefined && scopeInstanceId !== undefined) {
    payload.push({
      namespace: "dataSources",
      patches: [
        {
          op: "add",
          path: [nextDataSourceId],
          value: createResourceDataSource({
            dataSourceId: nextDataSourceId,
            scopeInstanceId,
            name: dataSourceName ?? resourceInput.name,
            resourceId,
          }),
        },
      ],
    });
  }

  return { payload, dataSourceId: nextDataSourceId, errors };
};

export const createResourceUpdatePayload = ({
  resource,
  values,
  dataSources,
  dataSourceName,
  scopeInstanceId,
}: {
  resource: Resource;
  values: z.infer<typeof resourceFieldsUpdateInput>;
  dataSources: Iterable<DataSource>;
  dataSourceName?: string;
  scopeInstanceId?: string;
}): BuilderPatchChange[] => {
  const patches = Object.entries(values).flatMap(([name, value]) =>
    value === undefined
      ? []
      : [{ op: "replace" as const, path: [resource.id, name], value }]
  );
  const payload: BuilderPatchChange[] = compactBuilderPatchPayload([
    { namespace: "resources", patches },
  ]);
  const dataSource = Array.from(dataSources).find(
    (dataSource) =>
      dataSource.type === "resource" && dataSource.resourceId === resource.id
  );
  const dataSourcePatches = [];
  if (dataSource !== undefined && dataSourceName !== undefined) {
    dataSourcePatches.push({
      op: "replace" as const,
      path: [dataSource.id, "name"],
      value: dataSourceName,
    });
  }
  if (dataSource !== undefined && scopeInstanceId !== undefined) {
    dataSourcePatches.push({
      op: "replace" as const,
      path: [dataSource.id, "scopeInstanceId"],
      value: scopeInstanceId,
    });
  }
  if (dataSourcePatches.length > 0) {
    payload.push({ namespace: "dataSources", patches: dataSourcePatches });
  }
  return payload;
};

export const createResourceDeletePayload = ({
  resource,
  instances,
  dataSources,
  props,
  force,
}: {
  resource: Resource;
  instances: ReadonlyMap<string, Pick<Instance, "component">>;
  dataSources: Iterable<DataSource>;
  props: Iterable<Prop>;
  force?: boolean;
}): {
  payload: BuilderPatchChange[];
  dataSourceIds: DataSource["id"][];
  propIds: Prop["id"][];
  isUsed: boolean;
} => {
  const propList = Array.from(props);
  const resourceProps = propList.filter(
    (prop) => prop.type === "resource" && prop.value === resource.id
  );
  const resourceDataSources = Array.from(dataSources).filter(
    (dataSource) =>
      dataSource.type === "resource" && dataSource.resourceId === resource.id
  );
  const resourceDataSourceIds = new Set(
    resourceDataSources.map(({ id }) => id)
  );
  const formSubmissionProps = propList.flatMap((prop) => {
    if (
      prop.type !== "json" ||
      prop.name !== "action" ||
      instances.get(prop.instanceId)?.component !== "ResourceForm" ||
      !isFormSubmission(prop.value) ||
      !prop.value.some((action) =>
        resourceDataSourceIds.has(action.dataSourceId)
      )
    ) {
      return [];
    }
    return [{ id: prop.id, value: prop.value }];
  });
  if (
    (resourceProps.length > 0 || formSubmissionProps.length > 0) &&
    force !== true
  ) {
    return { payload: [], dataSourceIds: [], propIds: [], isUsed: true };
  }
  const payload: BuilderPatchChange[] = [
    {
      namespace: "resources",
      patches: [{ op: "remove", path: [resource.id] }],
    },
  ];
  if (resourceDataSources.length > 0) {
    payload.push({
      namespace: "dataSources",
      patches: resourceDataSources.map((dataSource) => ({
        op: "remove" as const,
        path: [dataSource.id],
      })),
    });
  }
  if (resourceProps.length > 0 || formSubmissionProps.length > 0) {
    payload.push({
      namespace: "props",
      patches: [
        ...resourceProps.map((prop) => ({
          op: "remove" as const,
          path: [prop.id],
        })),
        ...formSubmissionProps.map((prop) => ({
          op: "replace" as const,
          path: [prop.id, "value"],
          value: removeFormActionsForResources(
            prop.value,
            resourceDataSourceIds
          ),
        })),
      ],
    });
  }

  return {
    payload,
    dataSourceIds: resourceDataSources.map((dataSource) => dataSource.id),
    propIds: resourceProps.map((prop) => prop.id),
    isUsed: false,
  };
};

export const serializeResources = ({
  resources,
  dataSources,
  scopeInstanceId,
}: {
  resources: Iterable<Resource> | Map<string, Resource>;
  dataSources: Iterable<DataSource> | Map<string, DataSource>;
  scopeInstanceId?: Instance["id"];
}) => {
  const dataSourceList =
    dataSources instanceof Map
      ? Array.from(dataSources.values())
      : Array.from(dataSources);
  return {
    resources: (resources instanceof Map
      ? Array.from(resources.values())
      : Array.from(resources)
    )
      .filter(
        (resource) =>
          scopeInstanceId === undefined ||
          dataSourceList.some(
            (dataSource) =>
              dataSource.type === "resource" &&
              dataSource.resourceId === resource.id &&
              dataSource.scopeInstanceId === scopeInstanceId
          )
      )
      .map((resource) => {
        const dataSource = dataSourceList.find(
          (dataSource) =>
            dataSource.type === "resource" &&
            dataSource.resourceId === resource.id &&
            (scopeInstanceId === undefined ||
              dataSource.scopeInstanceId === scopeInstanceId)
        );
        return {
          id: resource.id,
          name: resource.name,
          method: resource.method,
          url: resource.url,
          scopeInstanceId: dataSource?.scopeInstanceId,
          exposedAsDataSource: dataSource !== undefined,
          dataSourceId: dataSource?.id,
        };
      }),
  };
};

export const listResources = (
  state: Pick<BuilderState, "dataSources" | "resources">,
  input: { scopeInstanceId?: string } & PaginatedOutputInput = {}
) => {
  const serialized = serializeResources({
    resources: getRequiredResources(state),
    dataSources: getRequiredDataSources(state),
    scopeInstanceId: input.scopeInstanceId,
  });
  const { items, ...pagination } = paginateOutput({
    items: serialized.resources,
    cursor: input.cursor,
    limit: input.limit,
    filters: { scopeInstanceId: input.scopeInstanceId },
    verbose: input.verbose,
  });
  return { resources: items, ...pagination };
};

export const createResource = (
  state: Pick<
    BuilderState,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >,
  input: z.infer<typeof resourceCreateInput>,
  context: BuilderRuntimeContext
) => {
  const resourceInput = normalizeResourceFieldsInput(input.resource);
  validateResourceFields(resourceInput, ["resource"]);
  const build = getRequiredBuildData(state);
  validateEmailExpressionBindings({
    email: resourceInput.email,
    scopeInstanceId: input.scopeInstanceId ?? ROOT_INSTANCE_ID,
    instances: build.instances,
    dataSources: build.dataSources,
  });
  const resourceId = context.createId();
  const exposeAsDataSource =
    input.exposeAsDataSource ??
    (resourceInput.method === "get" && input.scopeInstanceId !== undefined);
  if (
    exposeAsDataSource &&
    input.scopeInstanceId !== ROOT_INSTANCE_ID &&
    build.instances.some(
      (instance) => instance.id === input.scopeInstanceId
    ) === false
  ) {
    return throwBuilderRuntimeError("NOT_FOUND", "Scope instance not found");
  }
  const dataSourceId = exposeAsDataSource ? context.createId() : undefined;
  const resultPayload = createResourceCreatePayload({
    resourceId,
    resource: resourceInput,
    resources: build.resources,
    dataSources: build.dataSources,
    dataSourceId,
    scopeInstanceId: input.scopeInstanceId,
    dataSourceName: input.dataSourceName,
  });
  const error = resultPayload.errors.at(0);
  if (error?.type === "duplicate-resource-id") {
    return throwBuilderRuntimeError("CONFLICT", "Resource id already exists");
  }
  if (error?.type === "duplicate-data-source-id") {
    return throwBuilderRuntimeError(
      "CONFLICT",
      "Data source id already exists"
    );
  }
  const resource = createResourceValue({
    id: resourceId,
    name: resourceInput.name,
    control: resourceInput.control,
    method: resourceInput.method,
    url: resourceInput.url,
    searchParams: resourceInput.searchParams,
    headers: resourceInput.headers,
    body: resourceInput.body,
    bodyFormat: resourceInput.bodyFormat,
    email: resourceInput.email,
  });
  const warnings = getResourceWarnings({
    fields: resource,
    state,
    scopeInstanceId: input.scopeInstanceId,
    resourceId,
    exposeAsDataSource,
    methodPath: ["resource", "method"],
  });
  return createRuntimeMutation({
    payload: createResourceUpsertPatchPayload({
      build,
      resource,
      dataSourceId,
      scopeInstanceId: input.scopeInstanceId,
      dataSourceName: input.dataSourceName,
      exposeAsDataSource,
    }),
    result: {
      resourceId,
      dataSourceId,
      warnings,
    },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
      "breakpoints",
      "styleSources",
      "styleSourceSelections",
      "styles",
    ],
  });
};

export const updateResource = (
  state: Pick<
    BuilderState,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >,
  input: z.infer<typeof resourceUpdateInput>,
  context: BuilderRuntimeContext,
  options?: { clearBody?: boolean }
) => {
  const clearBody = options?.clearBody === true;
  const values = normalizeResourceFieldsUpdateInput(input.values);
  validateResourceFields(values, ["values"]);
  const build = getRequiredBuildData(state);
  const resource = findResource(build.resources, input.resourceId);
  if (resource === undefined) {
    return throwBuilderRuntimeError("NOT_FOUND", "Resource not found");
  }
  if (
    clearBody === false &&
    Object.values(values).every((value) => value === undefined) &&
    input.dataSourceName === undefined &&
    input.scopeInstanceId === undefined &&
    input.exposeAsDataSource === undefined
  ) {
    return createRuntimeMutation({
      payload: [],
      result: { resourceId: resource.id },
      invalidatesNamespaces: [],
    });
  }
  const updatedEmail =
    values.email === undefined
      ? resource.email
      : { ...resource.email, ...values.email };
  if (values.email?.body !== undefined && updatedEmail !== undefined) {
    delete updatedEmail.confirmationBody;
  }
  const nextResource = createResourceValue({
    ...resource,
    ...values,
    email: updatedEmail,
    ...(clearBody ? { body: undefined } : {}),
  });
  if (nextResource.control !== "email" && nextResource.email !== undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Email settings require an Email Resource."
    );
  }
  if (values.email !== undefined) {
    emailSettingsInput.parse({
      control: nextResource.control,
      email: nextResource.email,
    });
  }
  const dataSource = build.dataSources.find(
    (dataSource) =>
      dataSource.type === "resource" && dataSource.resourceId === resource.id
  );
  const scopeInstanceId = input.scopeInstanceId ?? dataSource?.scopeInstanceId;
  const exposeAsDataSource =
    input.exposeAsDataSource ??
    (resource.method !== nextResource.method && nextResource.method !== "get"
      ? false
      : dataSource !== undefined ||
        (nextResource.method === "get" && scopeInstanceId !== undefined));
  if (exposeAsDataSource && scopeInstanceId === undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "scopeInstanceId is required when exposeAsDataSource is true."
    );
  }
  if (
    exposeAsDataSource &&
    scopeInstanceId !== ROOT_INSTANCE_ID &&
    build.instances.some((instance) => instance.id === scopeInstanceId) ===
      false
  ) {
    return throwBuilderRuntimeError("NOT_FOUND", "Scope instance not found");
  }
  const dataSourceId = exposeAsDataSource
    ? (dataSource?.id ?? context.createId())
    : dataSource?.id;
  validateEmailResourceConsumerBindings({
    email: nextResource.email,
    resourceId: resource.id,
    build,
    removedAliasId: exposeAsDataSource ? undefined : dataSource?.id,
    upsertedAlias:
      exposeAsDataSource &&
      dataSourceId !== undefined &&
      scopeInstanceId !== undefined
        ? { id: dataSourceId, scopeInstanceId }
        : undefined,
  });
  const warnings = getResourceWarnings({
    fields: nextResource,
    state,
    scopeInstanceId,
    resourceId: resource.id,
    exposeAsDataSource,
    fieldPath: ["values"],
    methodPath: ["values", "method"],
  });
  return createRuntimeMutation({
    payload: createResourceUpsertPatchPayload({
      build,
      resource: nextResource,
      dataSourceId,
      scopeInstanceId,
      dataSourceName: input.dataSourceName ?? dataSource?.name,
      exposeAsDataSource,
    }),
    result: {
      resourceId: resource.id,
      dataSourceId: exposeAsDataSource ? dataSourceId : undefined,
      warnings,
    },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
      "breakpoints",
      "styleSources",
      "styleSourceSelections",
      "styles",
    ],
  });
};

export const replaceResourceText = (
  state: Pick<BuilderState, "resources">,
  input: z.infer<typeof replaceResourceTextInput>
) => {
  const resourceIds =
    input.resourceIds === undefined ? undefined : new Set(input.resourceIds);
  const matches: Array<{
    resourceId: string;
    field: "name" | "url";
    before: string;
    after: string;
  }> = [];
  let matchingFieldCount = 0;
  for (const resource of getRequiredResources(state).values()) {
    if (resourceIds !== undefined && resourceIds.has(resource.id) === false) {
      continue;
    }
    const fields: Array<{
      field: "name" | "url";
      before: string | undefined;
    }> = [];
    if (input.fields.includes("name")) {
      fields.push({ field: "name", before: resource.name });
    }
    if (input.fields.includes("url")) {
      fields.push({
        field: "url",
        before: parseStringLiteralExpression(resource.url),
      });
    }
    for (const { field, before } of fields) {
      if (before === undefined) {
        continue;
      }
      const after = replaceTextValue(before, input);
      if (after === before) {
        continue;
      }
      matchingFieldCount += 1;
      if (matches.length >= input.limit) {
        continue;
      }
      if (field === "url") {
        validateResourceFields({ url: JSON.stringify(after) }, [
          "resources",
          resource.id,
        ]);
      }
      matches.push({ resourceId: resource.id, field, before, after });
    }
  }
  const result = {
    changedCount: matches.length,
    matchingFieldCount,
    truncated: matchingFieldCount > matches.length,
    matches,
  };
  return createRuntimeMutation({
    payload:
      matches.length === 0
        ? []
        : [
            {
              namespace: "resources",
              patches: matches.map(({ resourceId, field, after }) => ({
                op: "replace" as const,
                path: [resourceId, field],
                value: field === "url" ? JSON.stringify(after) : after,
              })),
            },
          ],
    result,
    invalidatesNamespaces: matches.length === 0 ? [] : ["resources"],
  });
};

export const upsertResource = (
  state: Pick<
    BuilderState,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >,
  input: z.infer<typeof resourceUpsertInput>,
  context: BuilderRuntimeContext
) => {
  const resourceInput = normalizeResourceFieldsInput(input.resource);
  validateResourceFields(resourceInput, ["resource"]);
  const build = getRequiredBuildData(state);
  if (
    input.resourceId !== undefined &&
    findResource(build.resources, input.resourceId) === undefined
  ) {
    return throwBuilderRuntimeError("NOT_FOUND", "Resource not found");
  }
  if (
    input.dataSourceId !== undefined &&
    build.dataSources.some(
      (dataSource) => dataSource.id === input.dataSourceId
    ) === false
  ) {
    return throwBuilderRuntimeError("NOT_FOUND", "Data source not found");
  }

  const resourceId = input.resourceId ?? context.createId();
  const dataSourceId = input.dataSourceId ?? context.createId();
  validateEmailResourceConsumerBindings({
    email: resourceInput.email,
    resourceId,
    build,
    upsertedAlias: { id: dataSourceId, scopeInstanceId: input.scopeInstanceId },
  });
  const resource = createResourceValue({
    id: resourceId,
    name: resourceInput.name,
    control: resourceInput.control,
    method: resourceInput.method,
    url: resourceInput.url,
    searchParams: resourceInput.searchParams,
    headers: resourceInput.headers,
    body: resourceInput.body,
    bodyFormat: resourceInput.bodyFormat,
    email: resourceInput.email,
  });

  return createRuntimeMutation({
    payload: createResourceUpsertPatchPayload({
      build,
      resource,
      dataSourceId,
      scopeInstanceId: input.scopeInstanceId,
      dataSourceName: input.dataSourceName,
    }),
    result: { resourceId, dataSourceId },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
      "breakpoints",
      "styleSources",
      "styleSourceSelections",
      "styles",
    ],
  });
};

export const upsertResourceProp = (
  state: Pick<
    BuilderState,
    | "pages"
    | "instances"
    | "props"
    | "dataSources"
    | "resources"
    | "breakpoints"
    | "styleSources"
    | "styleSourceSelections"
    | "styles"
  >,
  input: z.infer<typeof resourcePropUpsertInput>,
  context: BuilderRuntimeContext
) => {
  const resourceInput = normalizeResourceFieldsInput(input.resource);
  validateResourceFields(resourceInput, ["resource"]);
  const build = getRequiredBuildData(state);
  if (
    build.instances.some((instance) => instance.id === input.instanceId) ===
    false
  ) {
    return throwBuilderRuntimeError("NOT_FOUND", "Instance not found");
  }
  if (
    input.resourceId !== undefined &&
    findResource(build.resources, input.resourceId) === undefined
  ) {
    return throwBuilderRuntimeError("NOT_FOUND", "Resource not found");
  }

  const resourceId = input.resourceId ?? context.createId();
  // upsertResourceMutable removes the first Resource data source when the
  // prop Resource is saved without exposing it as render-time data.
  const removedAlias = build.dataSources.find(
    (dataSource) =>
      dataSource.type === "resource" && dataSource.resourceId === resourceId
  );
  validateEmailResourceConsumerBindings({
    email: resourceInput.email,
    resourceId,
    build,
    propInstanceId: input.instanceId,
    removedAliasId: removedAlias?.id,
  });
  const resource = createResourceValue({
    id: resourceId,
    name: resourceInput.name,
    control: resourceInput.control,
    method: resourceInput.method,
    url: resourceInput.url,
    searchParams: resourceInput.searchParams,
    headers: resourceInput.headers,
    body: resourceInput.body,
    bodyFormat: resourceInput.bodyFormat,
    email: resourceInput.email,
  });
  const existingProp = findProp(build.props, input.instanceId, input.propName);
  const nextProp = createValidatedPropValueFromInput(
    {
      propId: existingProp?.id,
      instanceId: input.instanceId,
      name: input.propName,
      type: "resource",
      value: resourceId,
    },
    context.createId
  );
  if (nextProp.success === false) {
    return throwBuilderRuntimeError("BAD_REQUEST", nextProp.errors.join("\n"));
  }
  const { payload: propPayload, propIds } = createPropUpsertPayload({
    props: build.props,
    nextProps: [nextProp.prop],
  });
  return createRuntimeMutation({
    payload: compactBuilderPatchPayload([
      ...createResourceUpsertPatchPayload({
        build,
        resource,
        exposeAsDataSource: false,
      }),
      ...propPayload,
    ]),
    result: { resourceId, dataSourceId: undefined, propIds },
    invalidatesNamespaces: [
      "pages",
      "instances",
      "props",
      "dataSources",
      "resources",
      "breakpoints",
      "styleSources",
      "styleSourceSelections",
      "styles",
    ],
  });
};

export const deleteResource = (
  state: Pick<
    BuilderState,
    "pages" | "instances" | "dataSources" | "resources" | "props"
  >,
  input: z.infer<typeof resourceDeleteInput>
) => {
  const resource = findResource(
    getRequiredResources(state).values(),
    input.resourceId
  );
  if (resource === undefined) {
    return throwBuilderRuntimeError("NOT_FOUND", "Resource not found");
  }
  if (state.pages === undefined || state.instances === undefined) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Pages or instances namespace is missing"
    );
  }
  const dataSources = getRequiredDataSources(state);
  const resourceDataSourceIds = new Set(
    Array.from(dataSources.values())
      .filter(
        (dataSource) =>
          dataSource.type === "resource" &&
          dataSource.resourceId === resource.id
      )
      .map((dataSource) => dataSource.id)
  );
  const usedDataSources = findUsedVariables({
    startingInstanceId: ROOT_INSTANCE_ID,
    pages: state.pages,
    instances: state.instances,
    props: getRequiredProps(state),
    dataSources,
    resources: getRequiredResources(state),
  });
  const referencedDataSourceIds = Array.from(resourceDataSourceIds).filter(
    (dataSourceId) => usedDataSources.has(dataSourceId)
  );
  if (referencedDataSourceIds.length > 0) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      `Resource data is referenced by expressions through ${referencedDataSourceIds.map((id) => JSON.stringify(id)).join(", ")}. Rebind or remove those expressions before deleting the resource.`
    );
  }
  const resultPayload = createResourceDeletePayload({
    resource,
    instances: state.instances,
    dataSources: dataSources.values(),
    props: getRequiredProps(state).values(),
    force: input.force,
  });
  if (resultPayload.isUsed) {
    return throwBuilderRuntimeError(
      "BAD_REQUEST",
      "Resource is used by props. Pass force to remove those prop references."
    );
  }
  return createRuntimeMutation({
    payload: resultPayload.payload,
    result: {
      resourceId: resource.id,
      dataSourceIds: resultPayload.dataSourceIds,
      propIds: resultPayload.propIds,
    },
    invalidatesNamespaces: ["resources", "dataSources", "props"],
  });
};