@superblocksteam/shared 0.9108.0

package/src/utils/apiv2.ts

@@ -0,0 +1,100 @@
+import { Value as ValuePb } from '@bufbuild/protobuf';
+import { GraphQLIntegrationPlugin } from '../plugins/templates/graphqlintegration';
+import { GOOGLE_SHEETS_PLUGIN_ID } from '../plugins/templates/gsheets';
+import { MariaDBPlugin } from '../plugins/templates/mariadb';
+import { MySQLPlugin } from '../plugins/templates/mysql';
+import { OpenAiPlugin } from '../plugins/templates/openai';
+import { extendsRestApiIntegrationPlugin } from '../types/plugin/integration';
+
+export const transcribeAudioToTextTranslateToEnglishTruthyValues = ['checked', 'true', true];
+export const transcribeAudioToTextTranslateToEnglishFalsyValues = [null, undefined, 'false', false];
+
+export const sanitizeV2RequestBody = (apiBody: Record<string, unknown>): Record<string, unknown> => {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  const traverseJSON = (obj: any) => {
+    for (const key in obj) {
+      if (key === 'step') {
+        if (obj.step[OpenAiPlugin.id]) {
+          const value = obj.step[OpenAiPlugin.id].transcribeAudioToTextTranslateToEnglish;
+          obj.step[OpenAiPlugin.id].transcribeAudioToTextTranslateToEnglish =
+            transcribeAudioToTextTranslateToEnglishTruthyValues.includes(value);
+          // cast generateTextNewTextMaxTokens as string
+          if (obj.step[OpenAiPlugin.id].generateTextNewTextMaxTokens) {
+            obj.step[OpenAiPlugin.id].generateTextNewTextMaxTokens = obj.step[OpenAiPlugin.id].generateTextNewTextMaxTokens.toString();
+          }
+        } else if (obj.step[MariaDBPlugin.id] && 'newValues' in obj.step[MariaDBPlugin.id]) {
+          // check if it's an array
+          if (Array.isArray(obj.step[MariaDBPlugin.id].newValues)) {
+            obj.step[MariaDBPlugin.id].newValues = '';
+          }
+        } else if (obj.step[MySQLPlugin.id] && 'newValues' in obj.step[MySQLPlugin.id]) {
+          // check if it's an array
+          if (Array.isArray(obj.step[MySQLPlugin.id].newValues)) {
+            obj.step[MySQLPlugin.id].newValues = '';
+          }
+        } else if (obj.step[GOOGLE_SHEETS_PLUGIN_ID] && 'rowNumber' in obj.step[GOOGLE_SHEETS_PLUGIN_ID]) {
+          obj.step[GOOGLE_SHEETS_PLUGIN_ID].rowNumber = obj.step[GOOGLE_SHEETS_PLUGIN_ID].rowNumber.toString();
+        } else if (obj.step[GraphQLIntegrationPlugin.id]) {
+          const stepConfig = obj.step[GraphQLIntegrationPlugin.id];
+          stepConfig.path = '';
+          stepConfig.headers = (stepConfig.headers ?? []).filter((header) => header.editable !== false);
+        }
+        for (const stepProperty of Object.keys(obj.step)) {
+          if (stepProperty === 'integration') continue;
+          if (extendsRestApiIntegrationPlugin(stepProperty)) {
+            const stepConfig = obj.step[stepProperty];
+            stepConfig.urlBase = '';
+            stepConfig.headers = (stepConfig.headers ?? []).filter((header) => header.editable !== false);
+            stepConfig.params = (stepConfig.params ?? []).filter((param) => param.editable !== false);
+          }
+        }
+      } else if (obj?.trigger?.workflow?.parameters?.query) {
+        const queryParams = obj.trigger.workflow.parameters.query;
+        // iterate over the keys of the query params
+        for (const queryParamKey in queryParams) {
+          // check if the query param is a string
+          if (typeof queryParams[queryParamKey] === 'string') {
+            queryParams[queryParamKey] = { values: [queryParams[queryParamKey]] };
+          }
+        }
+      } else if (obj[key] === null) {
+        obj[key] = ValuePb.fromJson(null);
+      } else if (key === 'variables' && 'items' in obj[key]) {
+        const variables = getVariables(obj[key]['items']);
+        obj[key]['items'] = variables;
+      } else if (typeof obj[key] === 'object') {
+        sanitizeV2RequestBody(obj[key]);
+      }
+    }
+  };
+  traverseJSON(apiBody);
+  return apiBody;
+};
+
+type Variable = {
+  mode: string;
+  value: string;
+  type: string;
+};
+
+type VariableWithKey = {
+  key: string;
+} & Variable;
+
+function getVariables(items: Record<string, Variable>): VariableWithKey[] {
+  const variables: VariableWithKey[] = [];
+  for (const key in items) {
+    const variableWithKey = {
+      key,
+      ...sanitizeVariableValue(items[key])
+    };
+    variables.push(variableWithKey);
+  }
+  return variables;
+}
+function sanitizeVariableValue(variable: Variable): Variable {
+  if (Array.isArray(variable.value)) {
+    variable.value = `{{${variable.value.join(',')}}}`;
+  }
+  return variable;
+}

package/src/utils/appDSL.ts

@@ -0,0 +1,21 @@
+// Hash the style string to create a predictable namespace
+// See https://stackoverflow.com/a/52171480/610632
+const cyrb53 = (str: string, seed = 0) => {
+  let h1 = 0xdeadbeef ^ seed,
+    h2 = 0x41c6ce57 ^ seed;
+  for (let i = 0, ch; i < str.length; i++) {
+    ch = str.charCodeAt(i);
+    h1 = Math.imul(h1 ^ ch, 2654435761);
+    h2 = Math.imul(h2 ^ ch, 1597334677);
+  }
+  h1 = Math.imul(h1 ^ (h1 >>> 16), 2246822507);
+  h1 ^= Math.imul(h2 ^ (h2 >>> 13), 3266489909);
+  h2 = Math.imul(h2 ^ (h2 >>> 16), 2246822507);
+  h2 ^= Math.imul(h1 ^ (h1 >>> 13), 3266489909);
+
+  return 4294967296 * (2097151 & h2) + (h1 >>> 0);
+};
+
+export const generatePredictableId = (name: string): string => {
+  return cyrb53(name).toString(36); // Convert to alphanumeric
+};

package/src/utils/bytestring.ts

@@ -0,0 +1,46 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+import _ from 'lodash';
+import { ExecutionContext } from '../types';
+
+/**
+ * Convert all objects that represent a bytestring to a node.js Buffer or a Uint8Array.
+ * Objects that that represent bytestrings are objects of the form {"type": "Buffer", data: [<array of bytes>]}.
+ * This is the kind of object that node.js returns when a Buffer is stringified as JSON.
+ * Note that as an optimization, the conversion (potentially) happens in place.
+ * @param value           An object that will be converted in place and recursively
+ * @param useNodeJSBuffer If true decode to node.js Buffer, otherwise use Uint8Array
+ * @returns The converted object with bytestrings replaced by Buffers or Uint8Arrays
+ *
+ * @remark
+ * Ensure you use the return value of this function because if the input value is a bytestring,
+ * it will NOT be converted in place.
+ *
+ */
+export function decodeBytestrings<T>(value: T, useNodeJSBuffer: boolean): T {
+  if (_.isObject(value)) {
+    if (
+      (value as any).type === 'Buffer' &&
+      Array.isArray((value as any).data) &&
+      (value as any).data.every((x: unknown) => _.isNumber(x))
+    ) {
+      if (useNodeJSBuffer) {
+        return Buffer.from(value as any) as unknown as T;
+      } else {
+        return new Uint8Array((value as any).data) as unknown as T;
+      }
+    } else {
+      for (const key in value) {
+        value[key] = decodeBytestrings(value[key], useNodeJSBuffer);
+      }
+    }
+  } else if (Array.isArray(value)) {
+    return value.map((val) => decodeBytestrings(val, useNodeJSBuffer)) as unknown as T;
+  }
+  return value;
+}
+
+export function decodeBytestringsExecutionContext(context: ExecutionContext, useNodeJSBuffer: boolean): void {
+  for (const key in context.outputs) {
+    context.outputs[key].output = decodeBytestrings(context.outputs[key].output, useNodeJSBuffer);
+  }
+}

package/src/utils/configuration.test.ts

@@ -0,0 +1,46 @@
+import { cloneDeep } from 'lodash';
+import { PostgresPlugin, RestApiIntegrationPlugin } from '../plugins';
+import { PostgresDatasourceConfiguration, Property, RestApiDatasourceConfiguration } from '../types';
+import { MASKED_SECRET, maskSecrets, unmaskSecrets } from './configuration';
+
+describe('configuration', () => {
+  test('can mask datasource field list secrets', () => {
+    const restApiIntegrationDatasourceConfiguration: RestApiDatasourceConfiguration = {
+      headers: [
+        {
+          key: 'Authorization',
+          value: 'foobar'
+        },
+        {
+          key: 'Content-Type',
+          value: 'foobar'
+        }
+      ]
+    };
+    const restoreConfiguration = cloneDeep(restApiIntegrationDatasourceConfiguration);
+
+    maskSecrets(restApiIntegrationDatasourceConfiguration, RestApiIntegrationPlugin);
+    let headers = restApiIntegrationDatasourceConfiguration.headers as Property[];
+    expect(headers[0].value).toBe(MASKED_SECRET);
+    expect(headers[1].value).toBe('foobar');
+    unmaskSecrets(restApiIntegrationDatasourceConfiguration, RestApiIntegrationPlugin, restoreConfiguration);
+    headers = restApiIntegrationDatasourceConfiguration.headers as Property[];
+    expect(headers[0].value).toBe('foobar');
+  });
+
+  test('can mask and unmask password input list secrets', () => {
+    const postgresDatasourceConfiguration: PostgresDatasourceConfiguration = {
+      authentication: {
+        username: 'foobar',
+        password: 'baz'
+      }
+    };
+    const restoreConfiguration = cloneDeep(postgresDatasourceConfiguration);
+
+    maskSecrets(postgresDatasourceConfiguration, PostgresPlugin);
+    expect(postgresDatasourceConfiguration.authentication?.password).toBe(MASKED_SECRET);
+    expect(postgresDatasourceConfiguration.authentication?.username).toBe('foobar');
+    unmaskSecrets(postgresDatasourceConfiguration, PostgresPlugin, restoreConfiguration);
+    expect(postgresDatasourceConfiguration.authentication?.password).toBe('baz');
+  });
+});

package/src/utils/configuration.ts

@@ -0,0 +1,84 @@
+import _ from 'lodash';
+import { FieldListFormItem, FormComponentType, FormItem, InputFormItem, Plugin, Property, getRowItemsFromSectionItem } from '../types';
+
+import { DatasourceConfiguration, InputDataType } from '../types';
+
+export const MASKED_SECRET = '<redacted>';
+
+export function maskSecrets(datasourceConfig: DatasourceConfiguration, plugin: Plugin): void {
+  plugin?.datasourceTemplate?.sections.forEach((section) => {
+    section.items.forEach((sectionItem) => {
+      const rowItems = getRowItemsFromSectionItem(sectionItem);
+      rowItems.forEach((item: FormItem) => {
+        if ((item as InputFormItem).dataType === InputDataType.PASSWORD) {
+          maskPassword(datasourceConfig, item);
+        } else if (item.componentType === FormComponentType.FIELD_LIST) {
+          maskFieldList(datasourceConfig, item);
+        }
+      });
+    });
+  });
+}
+
+function maskFieldList(datasourceConfig: DatasourceConfiguration, section: FieldListFormItem): void {
+  section.secretsNames?.forEach((secret) => {
+    (datasourceConfig[section.name] as Property[]).forEach((item) => {
+      if (item.key?.toUpperCase() === secret?.toUpperCase()) {
+        item.value = MASKED_SECRET;
+      }
+    });
+  });
+}
+
+function maskPassword(datasourceConfig: DatasourceConfiguration, section: FormItem): void {
+  _.set(datasourceConfig, section.name, MASKED_SECRET);
+}
+
+export function unmaskSecrets(
+  datasourceConfig: DatasourceConfiguration,
+  plugin: Plugin,
+  originalConfiguration: DatasourceConfiguration
+): void {
+  plugin?.datasourceTemplate?.sections.forEach((section) => {
+    section.items.forEach((sectionItem) => {
+      const rowItems = getRowItemsFromSectionItem(sectionItem);
+      rowItems.forEach((item: FormItem) => {
+        if ((item as InputFormItem).dataType === InputDataType.PASSWORD) {
+          unmaskPassword(datasourceConfig, item, originalConfiguration);
+        }
+        if (item.componentType === FormComponentType.FIELD_LIST) {
+          unmaskFieldList(datasourceConfig, item, originalConfiguration);
+        }
+      });
+    });
+  });
+}
+
+function unmaskFieldList(
+  datasourceConfig: DatasourceConfiguration,
+  fieldList: FieldListFormItem,
+  originalConfiguration: DatasourceConfiguration
+) {
+  if (fieldList.secretsNames) {
+    (fieldList.secretsNames as string[]).forEach((secret) => {
+      (datasourceConfig[fieldList.name] as Property[]).forEach((config) => {
+        if (config.key === secret) {
+          const originalValue: Property | undefined = _.find(
+            originalConfiguration[fieldList.name] as Property[],
+            (element) => element.key === secret,
+            0
+          );
+          if (originalValue) {
+            config.value = originalValue.value;
+          }
+        }
+      });
+    });
+  }
+}
+
+function unmaskPassword(datasourceConfig: DatasourceConfiguration, item: FormItem, originalConfiguration: DatasourceConfiguration) {
+  if (_.get(datasourceConfig, item.name) === MASKED_SECRET) {
+    _.set(datasourceConfig, item.name, _.get(originalConfiguration, item.name));
+  }
+}

package/src/utils/db.ts

@@ -0,0 +1,13 @@
+type ErrorWithCode = { code: string };
+const hasErrorCode = (err: unknown): err is ErrorWithCode => (err as ErrorWithCode).code !== undefined;
+
+const retryableErrorCodes = new Set(['40001']);
+
+// Errors with these Postgres error codes indicate that the query failed because
+// it conflicted with another transaction. This transaction needs to be retried
+// by the client.
+// Errors that are retryable will not be logged as errors since they are
+// expected occur and to be retried by the client.
+export const isRetryable = (err: unknown): boolean => {
+  return hasErrorCode(err) && retryableErrorCodes.has(err.code);
+};

package/src/utils/env.test.ts

@@ -0,0 +1,48 @@
+import { InvalidConfigurationError } from '../errors';
+import { EnvStore } from './env';
+
+describe('env store', () => {
+  test('errors when variable not set', () => {
+    const envStore = new EnvStore({
+      test1: 'value1'
+    });
+    expect(() => {
+      envStore.add({ name: 'test2' });
+    }).toThrowError(InvalidConfigurationError);
+    expect(() => {
+      envStore.addAll([{ name: 'test2' }, { name: 'test3', defaultValue: 'foo' }]);
+    }).toThrowError(InvalidConfigurationError);
+  });
+
+  test('can fetch value', () => {
+    const envStore = new EnvStore({
+      test1: 'value1',
+      test2: 'value2'
+    });
+    envStore.add({ name: 'test1' });
+    envStore.addAll([{ name: 'test2' }, { name: 'test3', defaultValue: 'value3' }]);
+    expect(envStore.get('test1')).toBe('value1');
+    expect(envStore.get('test2')).toBe('value2');
+    expect(envStore.get('test3')).toBe('value3');
+  });
+
+  test('errors when fetching value if not added', () => {
+    const envStore = new EnvStore({
+      test1: 'value1',
+      test2: 'value2'
+    });
+    envStore.add({ name: 'test1' });
+    expect(() => {
+      envStore.get('test2');
+    }).toThrowError(InvalidConfigurationError);
+  });
+
+  test('errors when fetching value if not added', () => {
+    const envStore = new EnvStore({
+      test1: 'value1',
+      test2: 'value2'
+    });
+    envStore.add({ name: 'test', regex: 'test.*', defaultValue: {} });
+    expect(envStore.get('test')).toEqual({ test1: 'value1', test2: 'value2' });
+  });
+});

package/src/utils/env.ts

@@ -0,0 +1,59 @@
+import { InvalidConfigurationError } from '../errors/configuration-error';
+
+export type Env = {
+  name: string;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  defaultValue?: any;
+  regex?: string;
+};
+
+export class EnvStore {
+  private vars: Record<string, Env>;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  private values: Record<string, any>;
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  constructor(values: Record<string, any>) {
+    this.vars = {};
+    this.values = values;
+  }
+
+  add(env: Env): void {
+    const name = env.name;
+    const value = this.values[name];
+    if (env.defaultValue === undefined && value == null) {
+      throw new InvalidConfigurationError(`Env variable ${name} is missing`);
+    }
+    // TODO validate env var with regex
+    this.vars[name] = env;
+  }
+
+  addAll(envs: Env[]): void {
+    for (const env of envs) {
+      this.add(env);
+    }
+  }
+
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  get(name: string): any {
+    const env = this.vars[name];
+    if (env === undefined) {
+      throw new InvalidConfigurationError(`Env variable ${name} is missing, use addEnv to add it first`);
+    }
+    if (env.regex) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const matchedKeys: Record<string, any> = {};
+      Object.entries(this.values).forEach(([key, value]) => {
+        if (key.match(env.regex ?? '')) {
+          matchedKeys[key] = value;
+        }
+      });
+      return matchedKeys;
+    }
+    const value = this.values[name];
+    if (value == null) {
+      return env.defaultValue;
+    }
+    return value;
+  }
+}

package/src/utils/environment.test.ts

@@ -0,0 +1,32 @@
+import { BadRequestError } from '../errors';
+import { DatasourceEnvironments, ENVIRONMENT_ALL, ENVIRONMENT_PRODUCTION, ENVIRONMENT_STAGING } from '../types';
+import { checkEnvironment, getDefaultDatasourceEnvironment, getDefaultEnvironment } from './environment';
+
+describe('default environment', () => {
+  test('returns the correct metadata for environment', () => {
+    expect(getDefaultEnvironment(true)).toBe(ENVIRONMENT_PRODUCTION);
+    expect(getDefaultDatasourceEnvironment(true)).toBe(DatasourceEnvironments.PRODUCTION);
+    expect(getDefaultEnvironment(false)).toBe(ENVIRONMENT_STAGING);
+    expect(getDefaultDatasourceEnvironment(false)).toBe(DatasourceEnvironments.STAGING);
+  });
+});
+
+describe('check environment', () => {
+  test('errors when environment is missing', () => {
+    expect(() => {
+      checkEnvironment('');
+    }).toThrowError(BadRequestError);
+  });
+
+  test('errors when environment is not valid', () => {
+    expect(() => {
+      checkEnvironment('foo');
+    }).toThrowError(BadRequestError);
+  });
+
+  test('accepts valid environments', () => {
+    expect(checkEnvironment(ENVIRONMENT_PRODUCTION)).toBe(ENVIRONMENT_PRODUCTION);
+    expect(checkEnvironment(ENVIRONMENT_STAGING)).toBe(ENVIRONMENT_STAGING);
+    expect(checkEnvironment(ENVIRONMENT_ALL)).toBe(ENVIRONMENT_ALL);
+  });
+});

package/src/utils/environment.ts

@@ -0,0 +1,24 @@
+import { BadRequestError } from '../errors';
+import { DatasourceEnvironments, ENVIRONMENT_PRODUCTION, ENVIRONMENT_STAGING, VALID_DATASOURCE_ENVIRONMENTS } from '../types';
+
+export function getDefaultEnvironment(isPublished: boolean): string {
+  return isPublished ? ENVIRONMENT_PRODUCTION : ENVIRONMENT_STAGING;
+}
+
+export function getDefaultDatasourceEnvironment(isPublished: boolean): DatasourceEnvironments {
+  return isPublished ? DatasourceEnvironments.PRODUCTION : DatasourceEnvironments.STAGING;
+}
+
+export function checkEnvironment(environment: string): string {
+  if (!environment) {
+    throw new BadRequestError(
+      `Environment is missing. Please choose one of the following environments: '${VALID_DATASOURCE_ENVIRONMENTS}'`
+    );
+  }
+  if (!VALID_DATASOURCE_ENVIRONMENTS.find((valid) => environment === valid)) {
+    throw new BadRequestError(
+      `An unsupported environment - '${environment}' - was provided. Please choose one of the following environments: '${VALID_DATASOURCE_ENVIRONMENTS}'`
+    );
+  }
+  return environment;
+}

package/src/utils/index.ts

@@ -0,0 +1,13 @@
+export * from './configuration';
+export * from './env';
+export * from './environment';
+export * from './string';
+export * from './time';
+export * from './truncate';
+export * from './url';
+export * from './db';
+export * from './bytestring';
+export * from './apiv2';
+export * from './page';
+export * from './normalize';
+export * from './normalizeRoleName';

package/src/utils/normalize.ts

@@ -0,0 +1,78 @@
+import { schema, denormalize as baseDenormalize } from 'normalizr';
+import { EntityWithBindings6, PageDSL8, WidgetProps, WidgetProps8, WidgetTypes } from '../types';
+import { getNextEntityName } from './string';
+
+const widgetSchema = new schema.Entity('canvasWidgets', {}, { idAttribute: 'widgetId' });
+widgetSchema.define({ children: [widgetSchema] });
+
+export type FlattenedWidgetProps = Omit<WidgetProps, 'children'> & {
+  type: keyof typeof WidgetTypes;
+  children?: string[];
+} & EntityWithBindings6;
+
+const PAGE_WIDGET_ID = '0';
+
+type WidgetMap = Record<string, FlattenedWidgetProps>;
+
+/**
+ * Fixes invalid DSL from previous bugs on initial load.
+ *  1. removes duplicate IDs
+ *  2. de-duplicates identical Section and Canvas names because their names don't matter
+ *  3. removes timers and stateVars from the page widget, as they are processed separately
+ */
+export function normalize<T = WidgetMap>(
+  dsl?: PageDSL8
+): {
+  entities: {
+    canvasWidgets: T;
+  };
+  result: string;
+} {
+  if (!dsl) return { entities: { canvasWidgets: {} as T }, result: '' };
+
+  const flattenedWidgets = {} as T;
+  const previouslySeenCanvasNames = new Set<string>();
+
+  function flattenWidget(widget: WidgetProps8): void {
+    if (flattenedWidgets[widget.widgetId]) return;
+    if (widget.children) {
+      flattenedWidgets[widget.widgetId] = {
+        ...widget,
+        children: Array.from(new Set(widget.children?.map((child) => child.widgetId)))
+      } as FlattenedWidgetProps;
+    } else {
+      flattenedWidgets[widget.widgetId] = widget as FlattenedWidgetProps;
+    }
+
+    if (widget.widgetId === PAGE_WIDGET_ID) {
+      // Extracted separately
+      delete widget.stateVars;
+      delete widget.timers;
+      delete widget.events;
+    }
+
+    if (
+      (widget.type === WidgetTypes.CANVAS_WIDGET || widget.type === WidgetTypes.SECTION_WIDGET) &&
+      previouslySeenCanvasNames.has(widget.widgetName)
+    ) {
+      const newName = getNextEntityName(widget.widgetName, Array.from(previouslySeenCanvasNames));
+      flattenedWidgets[widget.widgetId].widgetName = newName;
+      previouslySeenCanvasNames.add(newName);
+    } else {
+      previouslySeenCanvasNames.add(widget.widgetName);
+    }
+    if (widget.children) {
+      widget.children.forEach(flattenWidget);
+    }
+  }
+  flattenWidget(dsl);
+
+  return {
+    entities: { canvasWidgets: flattenedWidgets },
+    result: dsl.widgetId
+  };
+}
+
+export function denormalize<T = WidgetMap>(pageWidgetId: string, entities: { canvasWidgets: T }): PageDSL8 {
+  return baseDenormalize(pageWidgetId, widgetSchema, entities);
+}

package/src/utils/normalizeRoleName.ts

@@ -0,0 +1,7 @@
+export function normalizeRoleName(displayName: string): string {
+  const key = displayName
+    .trim() // remove leading/trailing whitespace
+    .replace(/^[\W_]+|[\W_]+$/g, '') // remove leading/trailing non-alphanumeric characters
+    .replace(/[\W_]+/g, '_'); // replace non-alphanumeric characters with underscores
+  return key.toLowerCase();
+}

package/src/utils/page.test.ts

@@ -0,0 +1,21 @@
+import { defaultPageLayouts } from './page';
+
+describe('page.ts', () => {
+  test.each(Object.entries(defaultPageLayouts))('getDefaultLayout snapshot %s', (version, genLayout) => {
+    const layout = genLayout();
+    expect(layout).toMatchSnapshot(version);
+
+    // modify the layout and check that it does not affect the next layout
+    layout.widgetName = 'NewName';
+
+    const layout2 = genLayout();
+    expect(layout2.widgetName).not.toBe('NewName');
+  });
+
+  describe('v8', () => {
+    test('with sections enabled', () => {
+      const v8Layout = defaultPageLayouts['8']();
+      expect(v8Layout.layoutVersion).toBe(2);
+    });
+  });
+});