@atlaskit/adf-schema/warn-schema-change.js

Shared package that contains the ADF-schema (json) and ProseMirror node/mark specs

module.exports = {
  meta: {
    type: 'suggestion',
    docs: {
      description:
        'Warn that changes to next-schema or schema should be reflected in the other.',
    },
    schema: [],
  },
  create(context) {
    const filename = context.filename;
    const nextSchemaFilesPattern =
      /.*\/adf-schema\/packages\/adf-schema\/src\/next-schema\/.*/;
    const schemaFilesPattern =
      /.*\/adf-schema\/packages\/adf-schema\/src\/schema\/.*/;

    const isInSchemaOrNextSchema =
      filename.match(nextSchemaFilesPattern) ||
      filename.match(schemaFilesPattern);

    const findDefine = (node) => {
      const callExpression = node;
      const memberExpression = callExpression.callee;
      const property = memberExpression.property;
      if (
        property &&
        property?.type === 'Identifier' &&
        property?.name === 'define'
      ) {
        return callExpression;
      }
      if (
        memberExpression &&
        memberExpression?.object?.type === 'CallExpression'
      ) {
        return findDefine(memberExpression.object);
      }
    };

    const reportInSchema = (objectExpression) => {
      if (!objectExpression) {
        return;
      }

      const parseDOMProp = objectExpression?.properties?.find(
        (p) => p?.key?.type === 'Identifier' && p?.key?.name === 'parseDOM',
      );

      const toDOMProp = objectExpression?.properties?.find(
        (p) => p?.key?.type === 'Identifier' && p?.key?.name === 'toDOM',
      );

      if (parseDOMProp) {
        context.report({
          node: parseDOMProp.key,
          message:
            'Changes to next-schema or schema should be reflected in the other.',
        });
      }

      if (toDOMProp) {
        context.report({
          node: toDOMProp.key,
          message:
            'Changes to next-schema or schema should be reflected in the other.',
        });
      }
    };

    const reportInNextSchema = (defineCallExpression) => {
      const defineArgs = defineCallExpression.arguments.find((p) => {
        return p.type === 'ObjectExpression';
      });
      const attrsProp = defineArgs?.properties?.find(
        (p) => p.key.type === 'Identifier' && p.key.name === 'attrs',
      );
      if (attrsProp) {
        context.report({
          node: attrsProp.key,
          message:
            'Changes to next-schema or schema should be reflected in the other.',
        });
      }
    };

    return {
      // packages/adf-schema/src/schema/nodes/unknown-block.ts
      ExportDefaultDeclaration: function (node) {
        if (!isInSchemaOrNextSchema) {
          return;
        }
        if (node?.declaration?.expression?.type === 'ObjectExpression') {
          const objectExpression = node.declaration.expression;
          reportInSchema(objectExpression);
        }
      },
      ExpressionStatement(node) {
        if (!isInSchemaOrNextSchema) {
          return;
        }
        if (node.expression.type === 'CallExpression') {
          const defineCallExpression = findDefine(node.expression);

          if (defineCallExpression) {
            reportInNextSchema(defineCallExpression);
          }
        }
      },
      ReturnStatement: function (node) {
        if (!isInSchemaOrNextSchema) {
          return;
        }
        if (node?.argument && node?.argument?.type === 'CallExpression') {
          const callExpression = node.argument;
          const args = callExpression.arguments;
          const objectExpression = args.find(
            (a) => a?.type === 'ObjectExpression',
          );
          if (objectExpression) {
            reportInSchema(objectExpression);
          }
        }
      },
      VariableDeclarator(node) {
        if (!isInSchemaOrNextSchema) {
          return;
        }
        if (node.init && node.init.type === 'ObjectExpression') {
          const objExpression = node.init;
          reportInSchema(objExpression);
        }
        if (node.init && node.init.type === 'CallExpression') {
          const callExpression = node.init;

          const arg = callExpression.arguments.find((a) => {
            return a.type === 'ObjectExpression';
          });

          if (arg) {
            reportInSchema(arg);
          }

          const define = findDefine(callExpression);

          if (define) {
            reportInNextSchema(define);
          }
        }
      },
    };
  },
};