@superblocksteam/shared 0.9108.0

package/src/refactoring/application.ts

@@ -0,0 +1,72 @@
+import { cloneDeep, set } from 'lodash';
+import { ApplicationConfiguration } from '../types';
+import { ScopedDataTree } from './refactor';
+import { Extractor } from './types';
+import { PropertyUpdate, updateNameInEntityMap } from './updates';
+
+export async function renameInApplicationConfiguration({
+  dsl,
+  oldName,
+  newName,
+  dataTree,
+  extractPairs,
+  namespace
+}: {
+  dsl: ApplicationConfiguration['dsl'];
+  oldName: string;
+  newName: string;
+  dataTree: ScopedDataTree;
+  extractPairs: Extractor;
+  namespace?: string;
+}): Promise<ApplicationConfiguration['dsl'] | undefined> {
+  const newDSL = cloneDeep(dsl);
+
+  if (!newDSL) {
+    return dsl;
+  }
+
+  let updates: PropertyUpdate[] = [];
+
+  if (newDSL?.events?.eventMap) {
+    const eventUpdates = await updateNameInEntityMap({
+      entityMap: newDSL?.events,
+      dataTree,
+      newName,
+      oldName,
+      namespace,
+      parentKey: 'events',
+      extractPairs
+    });
+    updates = [...updates, ...eventUpdates];
+  }
+
+  if (newDSL?.timers?.timerMap) {
+    const timerUpdates = await updateNameInEntityMap({
+      entityMap: newDSL?.timers,
+      dataTree,
+      newName,
+      oldName,
+      namespace,
+      parentKey: 'timers',
+      extractPairs
+    });
+    updates = [...updates, ...timerUpdates];
+  }
+
+  if (newDSL?.stateVars?.stateVarMap) {
+    const stateVarUpdates = await updateNameInEntityMap({
+      entityMap: newDSL?.stateVars,
+      dataTree,
+      newName,
+      oldName,
+      namespace,
+      parentKey: 'stateVars',
+      extractPairs
+    });
+    updates = [...updates, ...stateVarUpdates];
+  }
+
+  updates.forEach((update) => set(newDSL, update.propertyName, update.propertyValue));
+
+  return newDSL;
+}

package/src/refactoring/index.ts

@@ -0,0 +1,5 @@
+export * from './refactor';
+export * from './updates';
+export * from './types';
+export * from './rename';
+export * from './application';

package/src/refactoring/refactor.test.ts

@@ -0,0 +1,303 @@
+import { tokenize } from 'esprima';
+import { EvaluationPair, extractJsEvaluationPairsWithTokenizer, LanguagePluginID } from '../types';
+import { refactorNameInCode, refactorNameInString, refactorNameInValue, refactorNameInStep } from './refactor';
+
+describe('Refactoring', () => {
+  describe('Page Scope', () => {
+    describe('refactorNameInCode', () => {
+      it('should refactor the old name to the new name in the code', async () => {
+        const value = 'return oldName;';
+        const oldName = 'oldName';
+        const newName = 'newName';
+        const dataTree = {
+          oldName: {}
+        };
+
+        const result = await refactorNameInCode({
+          value,
+          oldName,
+          newName,
+          dataTree,
+          extractPairs: extractJsEvaluationPairs
+        });
+
+        expect(result).toEqual('return newName;');
+      });
+    });
+
+    describe('refactorNameInString', () => {
+      it('should refactor the old name to the new name in the string', async () => {
+        const value = 'Hello, {{oldName}}!';
+        const oldName = 'oldName';
+        const newName = 'newName';
+        const dataTree = {
+          oldName: {}
+        };
+
+        const result = await refactorNameInString({
+          value,
+          oldName,
+          newName,
+          dataTree,
+          extractPairs: extractJsEvaluationPairs
+        });
+
+        expect(result).toEqual('Hello, {{newName}}!');
+      });
+    });
+
+    describe('refactorNameInValue', () => {
+      it('in object', async () => {
+        const oldValue = {
+          name: '{{oldName}}',
+          age: 30
+        };
+        const oldName = 'oldName';
+        const newName = 'newName';
+        const dataTree = {
+          oldName: {}
+        };
+
+        const result = await refactorNameInValue({
+          oldValue,
+          oldName,
+          newName,
+          dataTree,
+          extractPairs: extractJsEvaluationPairs
+        });
+
+        expect(result).toEqual({
+          name: '{{newName}}',
+          age: 30
+        });
+      });
+    });
+
+    it('in array', async () => {
+      const oldValue = ['{{oldName}}', 30];
+      const oldName = 'oldName';
+      const newName = 'newName';
+      const dataTree = {
+        oldName: {}
+      };
+
+      const result = await refactorNameInValue({
+        oldValue,
+        oldName,
+        newName,
+        dataTree,
+        extractPairs: extractJsEvaluationPairs
+      });
+
+      expect(result).toEqual(['{{newName}}', 30]);
+    });
+    it('in string', async () => {
+      const oldValue = '{{oldName}}';
+      const oldName = 'oldName';
+      const newName = 'newName';
+      const dataTree = {
+        oldName: {}
+      };
+
+      const result = await refactorNameInValue({
+        oldValue,
+        oldName,
+        newName,
+        dataTree,
+        extractPairs: extractJsEvaluationPairs
+      });
+
+      expect(result).toEqual('{{newName}}');
+    });
+  });
+
+  describe('App Scope', () => {
+    describe('refactorNameInCode', () => {
+      it('should refactor the old name to the new name in the code', async () => {
+        const value = 'return App.oldName;';
+        const oldName = 'oldName';
+        const newName = 'newName';
+        const dataTree = {
+          oldName: {}
+        };
+
+        const result = await refactorNameInCode({
+          value,
+          oldName,
+          newName,
+          dataTree,
+          namespace: 'App',
+          extractPairs: extractJsEvaluationPairs
+        });
+
+        expect(result).toEqual('return App.newName;');
+      });
+    });
+
+    describe('refactorNameInString', () => {
+      it('should refactor the old name to the new name in the string', async () => {
+        const value = 'Hello, {{App.oldName}}!';
+        const oldName = 'oldName';
+        const newName = 'newName';
+        const dataTree = {
+          oldName: {}
+        };
+
+        const result = await refactorNameInString({
+          value,
+          oldName,
+          newName,
+          dataTree,
+          namespace: 'App',
+          extractPairs: extractJsEvaluationPairs
+        });
+
+        expect(result).toEqual('Hello, {{App.newName}}!');
+      });
+    });
+
+    describe('refactorNameInValue', () => {
+      it('in object', async () => {
+        const oldValue = {
+          name: '{{App.oldName}}',
+          age: 30
+        };
+        const oldName = 'oldName';
+        const newName = 'newName';
+        const dataTree = {
+          oldName: {}
+        };
+
+        const result = await refactorNameInValue({
+          oldValue,
+          oldName,
+          newName,
+          dataTree,
+          namespace: 'App',
+          extractPairs: extractJsEvaluationPairs
+        });
+
+        expect(result).toEqual({
+          name: '{{App.newName}}',
+          age: 30
+        });
+      });
+    });
+
+    it('in array', async () => {
+      const oldValue = ['{{App.oldName}}', 30];
+      const oldName = 'oldName';
+      const newName = 'newName';
+      const dataTree = {
+        oldName: {}
+      };
+
+      const result = await refactorNameInValue({
+        oldValue,
+        oldName,
+        newName,
+        dataTree,
+        namespace: 'App',
+        extractPairs: extractJsEvaluationPairs
+      });
+
+      expect(result).toEqual(['{{App.newName}}', 30]);
+    });
+    it('in string', async () => {
+      const oldValue = '{{App.oldName}}';
+      const oldName = 'oldName';
+      const newName = 'newName';
+      const dataTree = {
+        oldName: {}
+      };
+
+      const result = await refactorNameInValue({
+        oldValue,
+        oldName,
+        newName,
+        dataTree,
+        namespace: 'App',
+        extractPairs: extractJsEvaluationPairs
+      });
+
+      expect(result).toEqual('{{App.newName}}');
+    });
+  });
+
+  describe('refactorNameInStep', () => {
+    it('should refactor names in JS steps', async () => {
+      const oldName = 'oldName';
+      const newName = 'newName';
+      const dataTree = {
+        oldName: {}
+      };
+      const configuration = {
+        body: 'return {{oldName}};'
+      };
+      await refactorNameInStep({
+        configuration,
+        oldName,
+        newName,
+        dataTree,
+        namespace: undefined,
+        pluginId: LanguagePluginID.JavaScript,
+        extractor: extractJsEvaluationPairs
+      });
+      expect(configuration.body).toEqual('return {{newName}};');
+    });
+
+    it('should refactor names in steps with nested configurations, i.e. Databricks, Kinesis, etc', async () => {
+      const oldName = 'oldName';
+      const newName = 'newName';
+      const dataTree = {
+        oldName: {}
+      };
+      const configuration = {
+        get: {
+          limit: 10,
+          pollingCooldownMs: 1000,
+          shardIteratorType: 'SHARD_ITERATOR_TYPE_LATEST',
+          streamIdentifierType: 'STREAM_IDENTIFIER_STREAM_NAME'
+        },
+        put: {
+          data: '"test": {{oldName.text}}',
+          streamName: '{{oldName.text}}',
+          streamIdentifierType: 'STREAM_IDENTIFIER_STREAM_NAME'
+        },
+        operationType: 'OPERATION_TYPE_PUT'
+      };
+      await refactorNameInStep({
+        configuration,
+        oldName,
+        newName,
+        dataTree,
+        namespace: undefined,
+        pluginId: '12345',
+        extractor: extractJsEvaluationPairs
+      });
+      expect(configuration).toEqual({
+        get: {
+          limit: 10,
+          pollingCooldownMs: 1000,
+          shardIteratorType: 'SHARD_ITERATOR_TYPE_LATEST',
+          streamIdentifierType: 'STREAM_IDENTIFIER_STREAM_NAME'
+        },
+        put: {
+          data: '"test": {{newName.text}}',
+          streamName: '{{newName.text}}',
+          streamIdentifierType: 'STREAM_IDENTIFIER_STREAM_NAME'
+        },
+        operationType: 'OPERATION_TYPE_PUT'
+      });
+    });
+  });
+});
+
+async function extractJsEvaluationPairs(
+  jsSnippet: string,
+  entitiesToExtract: Set<string>,
+  dataTree: Record<Exclude<string, 'API' | 'WIDGETS'>, unknown>,
+  namespacedEntitiesToExtract?: Record<string, Set<string>>
+): Promise<EvaluationPair[]> {
+  return extractJsEvaluationPairsWithTokenizer(jsSnippet, entitiesToExtract, dataTree, tokenize, namespacedEntitiesToExtract);
+}

package/src/refactoring/refactor.ts

@@ -0,0 +1,278 @@
+import { isArray, isEqual, isObject, isString } from 'lodash';
+import { StringSegment, getDynamicStringSegments, isExactBinding, joinStringWithBindings } from '../bindings';
+import { LanguagePluginID } from '../types/plugin/language';
+import { Extractor } from './types';
+
+export type ScopedDataTree = { [entityName: string]: unknown };
+
+const splitStringWithBindings = (value: string): StringSegment[] => {
+  const stringSegments = getDynamicStringSegments(value.trim());
+
+  return stringSegments.map((segment) => {
+    const length = segment.length;
+
+    if (isExactBinding(segment)) {
+      return { dynamic: true, value: segment.substring(2, length - 2) };
+    }
+    return { dynamic: false, value: segment };
+  });
+};
+
+export async function refactorNameInCode({
+  value,
+  oldName,
+  newName,
+  dataTree,
+  extractPairs,
+  suffixes,
+  namespace
+}: {
+  value: string;
+  oldName: string;
+  newName: string;
+  dataTree: ScopedDataTree;
+  extractPairs: Extractor;
+  suffixes?: Array<string>;
+  namespace?: string;
+}) {
+  let pairs;
+
+  if (namespace) {
+    const namespacedEntitiesToExtract = {
+      [namespace]: new Set([oldName])
+    };
+    pairs = await extractPairs(value, new Set(), dataTree, namespacedEntitiesToExtract);
+  } else {
+    pairs = await extractPairs(value, new Set([oldName]), dataTree);
+  }
+  let position = 0;
+  let result = '';
+
+  for (const { binding, range } of pairs) {
+    if (suffixes) {
+      // only refactor if the code after the binding matches a suffix
+      const restOfCode = value.slice(range.start + binding.length);
+      if (!suffixes.some((suffix) => restOfCode.startsWith(suffix))) {
+        result += value.slice(position, range.end + 1);
+        position = range.end + 1;
+        continue;
+      }
+    }
+    result += value.slice(position, range.start) + newName;
+    position = range.start + binding.length;
+  }
+
+  return result + value.slice(position);
+}
+
+async function refactorNameInSegment({
+  segment,
+  oldName,
+  newName,
+  dataTree,
+  extractPairs,
+  namespace
+}: {
+  segment: StringSegment;
+  oldName: string;
+  newName: string;
+  dataTree: ScopedDataTree;
+  extractPairs: Extractor;
+  namespace?: string;
+}) {
+  if (segment.dynamic) {
+    const value = await refactorNameInCode({
+      value: segment.value,
+      oldName,
+      newName,
+      dataTree,
+      extractPairs,
+      namespace
+    });
+
+    if (value === null) {
+      return null;
+    }
+
+    return { dynamic: true, value };
+  }
+
+  return segment;
+}
+
+export async function refactorNameInString({
+  value,
+  oldName,
+  newName,
+  dataTree,
+  extractPairs,
+  namespace
+}: {
+  value: string;
+  oldName: string;
+  newName: string;
+  dataTree: ScopedDataTree;
+  extractPairs: Extractor;
+  namespace?: string;
+}) {
+  const segments = splitStringWithBindings(value);
+
+  const newSegments = await Promise.all(
+    segments.map((segment) => refactorNameInSegment({ segment, oldName, newName, dataTree, extractPairs, namespace }))
+  );
+
+  if (newSegments.filter((segment) => segment === null).length) {
+    return value;
+  }
+
+  return joinStringWithBindings(newSegments.filter((segment): segment is StringSegment => segment !== null));
+}
+
+export async function refactorNameInValue({
+  oldValue,
+  oldName,
+  newName,
+  dataTree,
+  extractPairs,
+  namespace,
+  includeNestedObjects
+}: {
+  oldValue: unknown;
+  oldName: string;
+  newName: string;
+  dataTree: ScopedDataTree;
+  extractPairs: Extractor;
+  namespace?: string;
+  includeNestedObjects?: boolean;
+}) {
+  if (isArray(oldValue)) {
+    return Promise.all(
+      oldValue.map(async (value) => {
+        if (typeof value === 'string') {
+          return refactorNameInString({
+            value,
+            oldName,
+            newName,
+            dataTree,
+            extractPairs,
+            namespace
+          });
+        } else if (includeNestedObjects && value !== null && typeof value === 'object') {
+          return refactorNameInValue({
+            oldValue: value,
+            oldName,
+            newName,
+            dataTree,
+            extractPairs,
+            namespace,
+            includeNestedObjects: true
+          });
+        } else {
+          return value;
+        }
+      })
+    );
+  } else if (isString(oldValue)) {
+    return refactorNameInString({
+      value: oldValue,
+      oldName,
+      newName,
+      dataTree,
+      extractPairs,
+      namespace
+    });
+  } else if (isObject(oldValue)) {
+    const entries = await Promise.all(
+      Object.entries(oldValue).map(async ([key, value]) => {
+        const newValue: unknown = await refactorNameInValue({
+          oldValue: value,
+          oldName,
+          newName,
+          dataTree,
+          extractPairs,
+          namespace,
+          includeNestedObjects
+        });
+        return [key, newValue];
+      })
+    );
+    return Object.fromEntries(entries);
+  }
+
+  return oldValue;
+}
+
+export function createFakeDataTree(dsls: Record<string, { name?: string; widgetName?: string }>[]): Record<string, unknown> {
+  const fakeDataTree = {};
+  for (const dsl of dsls) {
+    Object.values(dsl).forEach((entity) => {
+      const name = entity.name || entity.widgetName;
+      if (!name) {
+        return;
+      }
+      fakeDataTree[name] = {};
+    });
+  }
+  return fakeDataTree;
+}
+
+export async function refactorNameInStep({
+  oldName,
+  newName,
+  dataTree,
+  suffixes,
+  namespace,
+  configuration,
+  pluginId,
+  extractor
+}: {
+  oldName: string;
+  newName: string;
+  dataTree: ScopedDataTree;
+  suffixes?: string[];
+  namespace?: string;
+  pluginId?: string;
+  configuration: Record<string, unknown>;
+  extractor: Extractor;
+}) {
+  for (const [key, value] of Object.entries(configuration)) {
+    if (isString(value)) {
+      let newValue: string | null = null;
+      // Code body's vs plain text bodies (JS, Python vs HTTP, etc)
+      if (key === 'body' && (pluginId === LanguagePluginID.JavaScript || pluginId === LanguagePluginID.Python)) {
+        newValue = await refactorNameInCode({
+          value,
+          oldName,
+          newName,
+          dataTree,
+          extractPairs: extractor,
+          suffixes,
+          namespace
+        });
+      } else {
+        newValue = await refactorNameInString({
+          value,
+          oldName,
+          newName,
+          dataTree,
+          extractPairs: extractor,
+          namespace
+        });
+      }
+
+      if (!isEqual(newValue, value)) {
+        configuration[key] = newValue;
+      }
+    } else if (typeof value === 'object' && value !== null) {
+      configuration[key] = await refactorNameInValue({
+        oldValue: value,
+        oldName,
+        newName,
+        dataTree,
+        extractPairs: extractor,
+        namespace,
+        includeNestedObjects: true
+      });
+    }
+  }
+}