@powersync/service-module-mysql 0.7.4 → 0.9.0

package/src/types/node-sql-parser-extended-types.ts

@@ -0,0 +1,25 @@
+import 'node-sql-parser';
+
+/**
+ *  Missing Type definitions for the node-sql-parser
+ */
+declare module 'node-sql-parser' {
+  interface RenameStatement {
+    type: 'rename';
+    table: { db: string | null; table: string }[][];
+  }
+
+  interface TruncateStatement {
+    type: 'truncate';
+    keyword: 'table'; // There are more keywords possible, but we only care about 'table'
+    name: { db: string | null; table: string; as: string | null }[];
+  }
+
+  // This custom type more accurately describes what the structure of a Drop statement looks like for indexes.
+  interface DropIndexStatement {
+    type: 'drop';
+    keyword: 'index';
+    table: { db: string | null; table: string };
+    name: any[];
+  }
+}

package/src/utils/mysql-utils.ts

@@ -2,8 +2,8 @@ import { logger } from '@powersync/lib-services-framework';
 import mysql from 'mysql2';
 import mysqlPromise from 'mysql2/promise';
 import * as types from '../types/types.js';
-import { coerce, gte } from 'semver';
-import { SourceTable } from '@powersync/service-core';
+import { coerce, gte, satisfies } from 'semver';
+import { SourceEntityDescriptor } from '@powersync/service-core';
 
 export type RetriedQueryOptions = {
   connection: mysqlPromise.Connection;
@@ -86,6 +86,21 @@ export function isVersionAtLeast(version: string, minimumVersion: string): boole
   return gte(coercedVersion!, coercedMinimumVersion!, { loose: true });
 }
 
-export function escapeMysqlTableName(table: SourceTable): string {
-  return `\`${table.schema.replaceAll('`', '``')}\`.\`${table.table.replaceAll('`', '``')}\``;
+export function satisfiesVersion(version: string, targetVersion: string): boolean {
+  const coercedVersion = coerce(version);
+
+  return satisfies(coercedVersion!, targetVersion!, { loose: true });
+}
+
+export function qualifiedMySQLTable(table: SourceEntityDescriptor): string;
+export function qualifiedMySQLTable(table: string, schema: string): string;
+
+export function qualifiedMySQLTable(table: SourceEntityDescriptor | string, schema?: string): string {
+  if (typeof table === 'object') {
+    return `\`${table.schema.replaceAll('`', '``')}\`.\`${table.name.replaceAll('`', '``')}\``;
+  } else if (schema) {
+    return `\`${schema.replaceAll('`', '``')}\`.\`${table.replaceAll('`', '``')}\``;
+  } else {
+    return `\`${table.replaceAll('`', '``')}\``;
+  }
 }

package/src/utils/parser-utils.ts

@@ -0,0 +1,73 @@
+import { Alter, AST, Create, Drop, TruncateStatement, RenameStatement, DropIndexStatement } from 'node-sql-parser';
+
+// We ignore create table statements, since even in the worst case we will pick up the changes when row events for that
+// table are received.
+const DDL_KEYWORDS = ['alter table', 'drop table', 'truncate table', 'rename table'];
+
+/**
+ *  Check if a query is a DDL statement that applies to tables matching any of the provided matcher functions.
+ *  @param query
+ *  @param matchers
+ */
+export function matchedSchemaChangeQuery(query: string, matchers: ((table: string) => boolean)[]) {
+  // Normalize case and remove backticks for matching
+  const normalizedQuery = query.toLowerCase().replace(/`/g, '');
+
+  const isDDLQuery = DDL_KEYWORDS.some((keyword) => normalizedQuery.includes(keyword));
+  if (isDDLQuery) {
+    const tokens = normalizedQuery.split(/[^a-zA-Z0-9_`]+/);
+    // Check if any matched table names appear in the query
+    for (const token of tokens) {
+      const matchFound = matchers.some((matcher) => matcher(token));
+      if (matchFound) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}
+
+// @ts-ignore
+export function isTruncate(statement: AST): statement is TruncateStatement {
+  // @ts-ignore
+  return statement.type === 'truncate';
+}
+
+// @ts-ignore
+export function isRenameTable(statement: AST): statement is RenameStatement {
+  // @ts-ignore
+  return statement.type === 'rename';
+}
+
+export function isAlterTable(statement: AST): statement is Alter {
+  return statement.type === 'alter';
+}
+
+export function isRenameExpression(expression: any): boolean {
+  return expression.resource === 'table' && expression.action === 'rename';
+}
+
+export function isColumnExpression(expression: any): boolean {
+  return expression.resource === 'column';
+}
+
+export function isConstraintExpression(expression: any): boolean {
+  return (
+    (expression.resource === 'key' && expression.keyword === 'primary key') ||
+    expression.resource === 'constraint' ||
+    (expression.resource === 'index' && expression.action === 'drop')
+  );
+}
+
+export function isDropTable(statement: AST): statement is Drop {
+  return statement.type === 'drop' && statement.keyword === 'table';
+}
+
+export function isDropIndex(statement: AST): statement is DropIndexStatement {
+  return statement.type === 'drop' && statement.keyword === 'index';
+}
+
+export function isCreateUniqueIndex(statement: AST): statement is Create {
+  return statement.type === 'create' && statement.keyword === 'index' && statement.index_type === 'unique';
+}