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.

Drop legacy data sources from builder (#2319)

Bogdan Chadkin75f72eeccf2c
diff --git a/apps/builder/app/builder/features/settings-panel/props-section/use-props-logic.ts b/apps/builder/app/builder/features/settings-panel/props-section/use-props-logic.ts
index 38bdc25cc5..4d8d9fae5e 100644
--- a/apps/builder/app/builder/features/settings-panel/props-section/use-props-logic.ts
+++ b/apps/builder/app/builder/features/settings-panel/props-section/use-props-logic.ts
@@ -9,7 +9,7 @@ import {
import type { PropValue } from "../shared";
import { useStore } from "@nanostores/react";
import {
- dataSourceValuesStore,
+ dataSourcesLogicStore,
dataSourcesStore,
registeredComponentPropsMetasStore,
} from "~/shared/nano-states";
@@ -173,7 +173,7 @@ export const usePropsLogic = ({
instance.component
);
const dataSources = useStore(dataSourcesStore);
- const dataSourceValues = useStore(dataSourceValuesStore);
+ const dataSourcesLogic = useStore(dataSourcesLogicStore);
if (meta === undefined) {
throw new Error(`Could not get meta for component "${instance.component}"`);
@@ -186,7 +186,7 @@ export const usePropsLogic = ({
// convert data source prop to typed prop
const dataSourceId = prop.value;
const dataSource = dataSources.get(dataSourceId);
- const dataSourceValue = dataSourceValues.get(dataSourceId);
+ const dataSourceValue = dataSourcesLogic.get(dataSourceId);
if (dataSource === undefined) {
return [];
}
diff --git a/apps/builder/app/canvas/instance-selected.ts b/apps/builder/app/canvas/instance-selected.ts
index d96680be04..96fda33403 100644
--- a/apps/builder/app/canvas/instance-selected.ts
+++ b/apps/builder/app/canvas/instance-selected.ts
@@ -10,7 +10,7 @@ import {
stylesIndexStore,
instancesStore,
propsStore,
- dataSourceValuesStore,
+ dataSourcesLogicStore,
selectedInstanceSelectorStore,
dataSourceVariablesStore,
} from "~/shared/nano-states";
@@ -228,8 +228,8 @@ const subscribeSelectedInstance = (
const unsubscribeStylesIndexStore = stylesIndexStore.subscribe(update);
const unsubscribeInstancesStore = instancesStore.subscribe(update);
const unsubscribePropsStore = propsStore.subscribe(update);
- const unsubscribeDataSourceValuesStore =
- dataSourceValuesStore.subscribe(update);
+ const unsubscribeDataSourcesLogicStore =
+ dataSourcesLogicStore.subscribe(update);
const unsubscribeDataSourceVariablesStore =
dataSourceVariablesStore.subscribe(update);
@@ -276,7 +276,7 @@ const subscribeSelectedInstance = (
unsubscribeStylesIndexStore();
unsubscribeInstancesStore();
unsubscribePropsStore();
- unsubscribeDataSourceValuesStore();
+ unsubscribeDataSourcesLogicStore();
unsubscribeDataSourceVariablesStore();
};
};
diff --git a/apps/builder/app/shared/copy-paste/plugin-instance.ts b/apps/builder/app/shared/copy-paste/plugin-instance.ts
index 401773808f..45ae8c3a5c 100644
--- a/apps/builder/app/shared/copy-paste/plugin-instance.ts
+++ b/apps/builder/app/shared/copy-paste/plugin-instance.ts
@@ -33,8 +33,8 @@ import {
assetsStore,
projectStore,
registeredComponentMetasStore,
- dataSourceValuesStore,
dataSourcesStore,
+ dataSourcesLogicStore,
} from "../nano-states";
import {
type InstanceSelector,
@@ -246,7 +246,7 @@ const getTreeData = (targetInstanceSelector: InstanceSelector) => {
treeDataSources.map((dataSource) => dataSource.id)
);
- const dataSourceValues = dataSourceValuesStore.get();
+ const dataSourcesLogic = dataSourcesLogicStore.get();
const treeProps = getMapValuesBy(propsStore.get(), (prop) =>
treeInstanceIds.has(prop.instanceId)
).map((prop) => {
@@ -258,7 +258,7 @@ const getTreeData = (targetInstanceSelector: InstanceSelector) => {
}
// convert data source prop to typed prop
// when data source is not scoped to one of copied instances
- const value = dataSourceValues.get(dataSourceId);
+ const value = dataSourcesLogic.get(dataSourceId);
return {
id: prop.id,
instanceId: prop.instanceId,
diff --git a/apps/builder/app/shared/nano-states/nano-states.ts b/apps/builder/app/shared/nano-states/nano-states.ts
index c9cea36af0..9186c005f1 100644
--- a/apps/builder/app/shared/nano-states/nano-states.ts
+++ b/apps/builder/app/shared/nano-states/nano-states.ts
@@ -22,12 +22,7 @@ import {
type StyleSourceSelection,
type StyleSourceSelections,
} from "@webstudio-is/sdk";
-import {
- executeComputingExpressions,
- encodeDataSourceVariable,
- decodeDataSourceVariable,
- generateDataSources,
-} from "@webstudio-is/react-sdk";
+import { generateDataSources } from "@webstudio-is/react-sdk";
import type { Style } from "@webstudio-is/css-engine";
import type { DragStartPayload } from "~/canvas/shared/use-drag-drop";
import { useMount } from "~/shared/hook-utils/use-mount";
@@ -80,42 +75,6 @@ export const useSetDataSources = (
dataSourcesStore.set(new Map(dataSources));
});
};
-export const dataSourceValuesStore = computed(
- [dataSourcesStore, dataSourceVariablesStore],
- (dataSources, dataSourceVariables) => {
- const outputValues = new Map<DataSource["id"], unknown>();
- const variables = new Map<string, unknown>();
- const expressions = new Map<string, string>();
- for (const [dataSourceId, dataSource] of dataSources) {
- const name = encodeDataSourceVariable(dataSourceId);
- if (dataSource.type === "variable") {
- const value =
- dataSourceVariables.get(dataSourceId) ?? dataSource.value.value;
- variables.set(name, value);
- outputValues.set(dataSourceId, value);
- }
- if (dataSource.type === "expression") {
- expressions.set(name, dataSource.code);
- }
- }
- try {
- const outputVariables = executeComputingExpressions(
- expressions,
- variables
- );
- for (const [name, value] of outputVariables) {
- const id = decodeDataSourceVariable(name);
- if (id !== undefined) {
- outputValues.set(id, value);
- }
- }
- } catch (error) {
- // eslint-disable-next-line no-console
- console.error(error);
- }
- return outputValues;
- }
-);
export const propsStore = atom<Props>(new Map());
export const propsIndexStore = computed(propsStore, (props) => {
diff --git a/packages/cli/src/prebuild.ts b/packages/cli/src/prebuild.ts
index c5b640970d..5667095a44 100644
--- a/packages/cli/src/prebuild.ts
+++ b/packages/cli/src/prebuild.ts
@@ -357,11 +357,7 @@ export const prebuild = async (options: {
"user",
"projectId",
"indexesWithinAncestors",
- "rawExecuteComputingExpressions",
- "executeComputingExpressions",
- "generatedEffectfulExpressions",
- "rawExecuteEffectfulExpression",
- "executeEffectfulExpression",
+ "getDataSourcesLogic",
"utils",
]);
const namespaces = new Map<
diff --git a/packages/react-sdk/src/expression.test.ts b/packages/react-sdk/src/expression.test.ts
index 7fd9f128bf..afbe0d01d8 100644
--- a/packages/react-sdk/src/expression.test.ts
+++ b/packages/react-sdk/src/expression.test.ts
@@ -2,11 +2,7 @@ import { expect, test } from "@jest/globals";
import {
decodeDataSourceVariable,
encodeDataSourceVariable,
- executeComputingExpressions,
- executeEffectfulExpression,
computeExpressionsDependencies,
- generateComputingExpressions,
- generateEffectfulExpression,
validateExpression,
generateDataSources,
} from "./expression";
@@ -91,92 +87,6 @@ test("transform identifiers", () => {
).toEqual(`$ws$a + $ws$b`);
});
-test("generate computing expressions", () => {
- const variables = new Set(["var0"]);
- const expressions = new Map([
- ["exp3", "exp2 + exp1"],
- ["exp1", "var0"],
- ["exp2", "exp1"],
- ["exp4", "exp2"],
- ]);
- expect(generateComputingExpressions(expressions, variables))
- .toMatchInlineSnapshot(`
- "const var0 = _variables.get('var0');
- const exp1 = (var0);
- const exp2 = (exp1);
- const exp3 = (exp2 + exp1);
- const exp4 = (exp2);
- return new Map([
- ['exp1', exp1],
- ['exp2', exp2],
- ['exp3', exp3],
- ['exp4', exp4],
- ]);"
- `);
-});
-
-test("add only used variables in computing expression", () => {
- const expressions = new Map([["exp1", "var0"]]);
- expect(generateComputingExpressions(expressions, new Set(["var0", "var1"])))
- .toMatchInlineSnapshot(`
- "const var0 = _variables.get('var0');
- const exp1 = (var0);
- return new Map([
- ['exp1', exp1],
- ]);"
- `);
-});
-
-test("execute expression", () => {
- const variables = new Map();
- const expressions = new Map([["exp1", "1 + 1"]]);
- expect(executeComputingExpressions(expressions, variables)).toEqual(
- new Map([["exp1", 2]])
- );
-});
-
-test("execute expression dependent on variables", () => {
- const variables = new Map([["var1", 5]]);
- const expressions = new Map([["exp1", "var1 + 1"]]);
- expect(executeComputingExpressions(expressions, variables)).toEqual(
- new Map([["exp1", 6]])
- );
-});
-
-test("execute expression dependent on another expressions", () => {
- const variables = new Map([["var1", 3]]);
- const expressions = new Map([
- ["exp1", "exp0 + 1"],
- ["exp0", "var1 + 2"],
- ]);
- expect(executeComputingExpressions(expressions, variables)).toEqual(
- new Map([
- ["exp1", 6],
- ["exp0", 5],
- ])
- );
-});
-
-test("forbid circular expressions", () => {
- const variables = new Map([["var1", 3]]);
- const expressions = new Map([
- ["exp0", "exp2 + 1"],
- ["exp1", "exp0 + 2"],
- ["exp2", "exp1 + 3"],
- ]);
- expect(() => {
- executeComputingExpressions(expressions, variables);
- }).toThrowError(/Cannot access 'exp0' before initialization/);
-});
-
-test("make sure dependency exists", () => {
- const variables = new Map();
- const expressions = new Map([["exp1", "var1 + 1"]]);
- expect(() => {
- executeComputingExpressions(expressions, variables);
- }).toThrowError(/Unknown dependency "var1"/);
-});
-
test("encode/decode variable names", () => {
expect(encodeDataSourceVariable("my--id")).toEqual(
"$ws$dataSource$my__DASH____DASH__id"
@@ -187,99 +97,6 @@ test("encode/decode variable names", () => {
expect(decodeDataSourceVariable("myVarName")).toEqual(undefined);
});
-test("generate effectful expression", () => {
- expect(
- generateEffectfulExpression(
- `var0 = var0 + var1`,
- new Set(),
- new Set(["var0", "var1"])
- )
- ).toMatchInlineSnapshot(`
- "let var0 = _variables.get('var0');
- let var1 = _variables.get('var1');
- var0 = var0 + var1;
- return new Map([
- ['var0', var0],
- ]);"
- `);
-
- expect(
- generateEffectfulExpression(
- `var0 = var1 + 1`,
- new Set(),
- new Set(["var0", "var1"])
- )
- ).toMatchInlineSnapshot(`
- "let var1 = _variables.get('var1');
- let var0;
- var0 = var1 + 1;
- return new Map([
- ['var0', var0],
- ]);"
- `);
-});
-
-test("add only used variables in effectful expression", () => {
- expect(
- generateEffectfulExpression(
- `var0 = var1 + 1`,
- new Set(),
- new Set(["var0", "var1", "var2"])
- )
- ).toMatchInlineSnapshot(`
- "let var1 = _variables.get('var1');
- let var0;
- var0 = var1 + 1;
- return new Map([
- ['var0', var0],
- ]);"
- `);
-});
-
-test("support effectful expression arguments", () => {
- expect(
- generateEffectfulExpression(
- `var0 = arg0 + 1`,
- new Set(["arg0"]),
- new Set(["var0"])
- )
- ).toMatchInlineSnapshot(`
- "let arg0 = _args.get('arg0');
- let var0;
- var0 = arg0 + 1;
- return new Map([
- ['var0', var0],
- ]);"
- `);
-});
-
-test("forbid not allowed variables or arguments in effectful expression", () => {
- expect(() => {
- generateEffectfulExpression(
- `var0 = var0 + var1`,
- new Set(),
- new Set(["var0"])
- );
- }).toThrowError(/Unknown dependency "var1"/);
- expect(() => {
- generateEffectfulExpression(`var0 = arg0`, new Set(), new Set(["var0"]));
- }).toThrowError(/Unknown dependency "arg0"/);
-});
-
-test("execute effectful expression", () => {
- const variables = new Map([
- ["var0", 2],
- ["var1", 3],
- ]);
- expect(
- executeEffectfulExpression(`var0 = var0 + var1`, new Map(), variables)
- ).toEqual(new Map([["var0", 5]]));
-
- expect(
- executeEffectfulExpression(`arg0 = 5`, new Map([["arg0", 0]]), new Map())
- ).toEqual(new Map());
-});
-
test("compute expressions dependencies", () => {
const expressions = new Map([
["exp1", `var1`],
diff --git a/packages/react-sdk/src/expression.ts b/packages/react-sdk/src/expression.ts
index 092d6a75c8..4cb8fa0b8d 100644
--- a/packages/react-sdk/src/expression.ts
+++ b/packages/react-sdk/src/expression.ts
@@ -181,142 +181,6 @@ const sortTopologically = (
return sorted;
};
-/**
- * Generates a function body expecting map as _variables argument
- * and outputing map of results
- */
-export const generateComputingExpressions = (
- expressions: Map<string, string>,
- allowedVariables: Set<string>
-) => {
- const depsById = new Map<string, Set<string>>();
- const inputVariables = new Set<string>();
- for (const [id, code] of expressions) {
- const deps = new Set<string>();
- validateExpression(code, {
- transformIdentifier: (identifier) => {
- if (allowedVariables.has(identifier)) {
- inputVariables.add(identifier);
- return identifier;
- }
- if (expressions.has(identifier)) {
- deps.add(identifier);
- return identifier;
- }
- throw Error(`Unknown dependency "${identifier}"`);
- },
- });
- depsById.set(id, deps);
- }
-
- const sortedExpressions = sortTopologically(
- new Set(expressions.keys()),
- depsById
- );
-
- // generate code computing all expressions
- let generatedCode = "";
-
- for (const id of inputVariables) {
- generatedCode += `const ${id} = _variables.get('${id}');\n`;
- }
-
- for (const id of sortedExpressions) {
- const code = expressions.get(id);
- if (code === undefined) {
- continue;
- }
- generatedCode += `const ${id} = (${code});\n`;
- }
-
- generatedCode += `return new Map([\n`;
- for (const id of sortedExpressions) {
- generatedCode += ` ['${id}', ${id}],\n`;
- }
- generatedCode += `]);`;
-
- return generatedCode;
-};
-
-export const executeComputingExpressions = (
- expressions: Map<string, string>,
- variables: Map<string, unknown>
-) => {
- const generatedCode = generateComputingExpressions(
- expressions,
- new Set(variables.keys())
- );
- const executeFn = new Function("_variables", generatedCode);
- const values = executeFn(variables) as Map<string, unknown>;
- return values;
-};
-
-export const generateEffectfulExpression = (
- code: string,
- args: Set<string>,
- allowedVariables: Set<string>
-) => {
- const inputVariables = new Set<string>();
- const outputVariables = new Set<string>();
- validateExpression(code, {
- effectful: true,
- transformIdentifier: (identifier, assignee) => {
- if (args.has(identifier)) {
- return identifier;
- }
- if (allowedVariables.has(identifier)) {
- if (assignee) {
- outputVariables.add(identifier);
- } else {
- inputVariables.add(identifier);
- }
- return identifier;
- }
- throw Error(`Unknown dependency "${identifier}"`);
- },
- });
-
- // generate code computing all expressions
- let generatedCode = "";
-
- for (const id of args) {
- generatedCode += `let ${id} = _args.get('${id}');\n`;
- }
- for (const id of inputVariables) {
- generatedCode += `let ${id} = _variables.get('${id}');\n`;
- }
- for (const id of outputVariables) {
- if (inputVariables.has(id) === false) {
- generatedCode += `let ${id};\n`;
- }
- }
-
- generatedCode += `${code};\n`;
-
- generatedCode += `return new Map([\n`;
- for (const id of outputVariables) {
- generatedCode += ` ['${id}', ${id}],\n`;
- }
- generatedCode += `]);`;
-
- return generatedCode;
-};
-
-export const executeEffectfulExpression = (
- code: string,
- args: Map<string, unknown>,
- variables: Map<string, unknown>
-) => {
- const generatedCode = generateEffectfulExpression(
- code,
- new Set(args.keys()),
- new Set(variables.keys())
- );
- const executeFn = new Function("_variables", "_args", generatedCode);
- const values = executeFn(variables, args) as Map<string, unknown>;
- return values;
-};
-
const computeExpressionDependencies = (
expressions: Map<string, string>,
expressionId: string,
@@ -361,8 +225,6 @@ export const computeExpressionsDependencies = (
return dependencies;
};
-type Values = Map<string, unknown>;
-
const dataSourceVariablePrefix = "$ws$dataSource$";
// data source id is generated with nanoid which has "-" in alphabeta
@@ -374,14 +236,6 @@ export const encodeDataSourceVariable = (id: string) => {
return `${dataSourceVariablePrefix}${encoded}`;
};
-export const encodeVariablesMap = (values: Values) => {
- const encodedValues: Values = new Map();
- for (const [id, value] of values) {
- encodedValues.set(encodeDataSourceVariable(id), value);
- }
- return encodedValues;
-};
-
export const decodeDataSourceVariable = (name: string) => {
if (name.startsWith(dataSourceVariablePrefix)) {
const encoded = name.slice(dataSourceVariablePrefix.length);
@@ -390,17 +244,6 @@ export const decodeDataSourceVariable = (name: string) => {
return;
};
-export const decodeVariablesMap = (values: Values) => {
- const decodedValues: Values = new Map();
- for (const [name, value] of values) {
- const id = decodeDataSourceVariable(name);
- if (id !== undefined) {
- decodedValues.set(id, value);
- }
- }
- return decodedValues;
-};
-
/*
// header
diff --git a/packages/react-sdk/src/index.ts b/packages/react-sdk/src/index.ts
index 1779470b9c..331d1e14a9 100644
--- a/packages/react-sdk/src/index.ts
+++ b/packages/react-sdk/src/index.ts
@@ -23,15 +23,9 @@ export {
export { type Params, ReactSdkContext } from "./context";
export {
validateExpression,
- generateComputingExpressions,
- executeComputingExpressions,
- generateEffectfulExpression,
- executeEffectfulExpression,
computeExpressionsDependencies,
encodeDataSourceVariable,
- encodeVariablesMap,
decodeDataSourceVariable,
- decodeVariablesMap,
generateDataSources,
} from "./expression";
export { renderComponentTemplate } from "./component-renderer";