@pgsql/transform 18.15.2 → 18.15.3

package/esm/transform.js

@@ -197,7 +197,9 @@ export function transformSchemaRefsInString(str, schemaMapping, result) {
     // References embedded in opaque strings carry no object identity, so only
     // whole-schema (schema-level default) routes can be applied here.
     for (const [oldSchema, newSchema] of schemaLevelMap(schemaMapping)) {
-        const pattern = new RegExp(`(?<![\\w-])("?)${escapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
+        if (!out.includes(oldSchema))
+            continue;
+        const pattern = cachedRegExp(`(?<![\\w-])("?)${cachedEscapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
         const before = out;
         out = out.replace(pattern, `$1${newSchema}$1`);
         if (out !== before) {
@@ -618,14 +620,19 @@ export function validateNoUntransformedSchemas(content, schemaMapping) {
     if (moved.size === 0) {
         return;
     }
+    // Every pattern below requires a literal occurrence of the schema name, so a
+    // single case-insensitive substring scan rules out most schemas up front.
+    const lowerContent = content.toLowerCase();
     for (const [oldSchema, newSchema] of moved) {
-        const escapedSchema = escapeRegexp(oldSchema);
+        if (!lowerContent.includes(oldSchema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(oldSchema);
         // Pattern 1: quoted or unquoted schema name followed by dot (schema-qualified)
-        const dotPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
+        const dotPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
         // Pattern 2: standalone schema name in known SQL contexts
         // Note: We don't use trailing \b because it fails after closing quotes
         // (both '"' and whitespace are non-word characters, so no boundary exists).
-        const standalonePattern = new RegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
+        const standalonePattern = cachedRegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
             `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
         const dotMatches = content.match(dotPattern);
         const standaloneMatches = content.match(standalonePattern);
@@ -633,7 +640,7 @@ export function validateNoUntransformedSchemas(content, schemaMapping) {
         if (totalMatches > 0) {
             const lines = content.split('\n');
             const locations = [];
-            const combinedPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
+            const combinedPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
                 `(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
                 `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
             for (let i = 0; i < lines.length; i++) {
@@ -878,6 +885,34 @@ function transformSchemasInContext(ctx, schemaMapping, result, visitorOptions) {
 export function escapeRegexp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Compiling a pattern costs far more than running it, and the string-level
+ * passes below rebuild the same handful of per-schema patterns for every file
+ * they touch — on a large corpus that is hundreds of thousands of identical
+ * compiles. Patterns are keyed by source + flags and reused; each returned
+ * RegExp is stateful (`g`/`y` carry `lastIndex`), so callers must only use it
+ * with `String#replace`/`String#match`, which reset it, or reset it
+ * themselves, exactly as the throwaway instances required.
+ */
+const regExpCache = new Map();
+function cachedRegExp(source, flags) {
+    const key = `${flags}\u0000${source}`;
+    let re = regExpCache.get(key);
+    if (!re) {
+        re = new RegExp(source, flags);
+        regExpCache.set(key, re);
+    }
+    return re;
+}
+const escapeRegexpCache = new Map();
+function cachedEscapeRegexp(str) {
+    let escaped = escapeRegexpCache.get(str);
+    if (escaped === undefined) {
+        escaped = escapeRegexp(str);
+        escapeRegexpCache.set(str, escaped);
+    }
+    return escaped;
+}
 /**
  * Extract pgpm header comments from the beginning of SQL content.
  */
@@ -936,7 +971,7 @@ export function transformComments(content, schemaMapping, result) {
             if (!newName)
                 continue;
             result.schemasFound.add(schema);
-            const pathPattern = new RegExp(`(schemas/)${escapeRegexp(schema)}(/|$)`, 'g');
+            const pathPattern = cachedRegExp(`(schemas/)${cachedEscapeRegexp(schema)}(/|$)`, 'g');
             const before = newPath;
             newPath = newPath.replace(pathPattern, `$1${newName}$2`);
             if (newPath !== before) {
@@ -953,15 +988,20 @@ export function transformComments(content, schemaMapping, result) {
 export function transformVerifyCalls(content, schemaMapping, result) {
     const schemas = Array.from(schemaMapping.keys()).sort((a, b) => b.length - a.length);
     let newContent = content;
+    // The pattern needs the schema name spelled out, case-insensitively.
+    let lowerContent = content.toLowerCase();
     for (const schema of schemas) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const verifyPattern = new RegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
+        if (!lowerContent.includes(schema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const verifyPattern = cachedRegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
         const before = newContent;
         newContent = newContent.replace(verifyPattern, `$1${newName}$2`);
         if (newContent !== before) {
+            lowerContent = newContent.toLowerCase();
             result.schemasFound.add(schema);
             result.schemasTransformed.set(schema, newName);
         }
@@ -978,8 +1018,10 @@ export function transformJsonStringValues(content, schemaMapping, result) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const jsonValuePattern = new RegExp(`(:")${escapedSchema}(")`, 'g');
+        if (!newContent.includes(schema))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const jsonValuePattern = cachedRegExp(`(:")${escapedSchema}(")`, 'g');
         const before = newContent;
         newContent = newContent.replace(jsonValuePattern, `$1${newName}$2`);
         if (newContent !== before) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pgsql/transform",
-  "version": "18.15.2",
+  "version": "18.15.3",
   "author": "Constructive <developers@constructive.io>",
   "description": "AST-based SQL transformation, qualification, classification and closure analysis for PostgreSQL",
   "main": "index.js",
@@ -50,5 +50,5 @@
     "classify",
     "plpgsql"
   ],
-  "gitHead": "b6105874628cc7b8517c1ebbd99e9ad6fe786976"
+  "gitHead": "69cdce673db035fb1ee3b529480d39fac01512ab"
 }

package/transform.js

@@ -218,7 +218,9 @@ function transformSchemaRefsInString(str, schemaMapping, result) {
     // References embedded in opaque strings carry no object identity, so only
     // whole-schema (schema-level default) routes can be applied here.
     for (const [oldSchema, newSchema] of schemaLevelMap(schemaMapping)) {
-        const pattern = new RegExp(`(?<![\\w-])("?)${escapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
+        if (!out.includes(oldSchema))
+            continue;
+        const pattern = cachedRegExp(`(?<![\\w-])("?)${cachedEscapeRegexp(oldSchema)}\\1(?=\\.)`, 'g');
         const before = out;
         out = out.replace(pattern, `$1${newSchema}$1`);
         if (out !== before) {
@@ -639,14 +641,19 @@ function validateNoUntransformedSchemas(content, schemaMapping) {
     if (moved.size === 0) {
         return;
     }
+    // Every pattern below requires a literal occurrence of the schema name, so a
+    // single case-insensitive substring scan rules out most schemas up front.
+    const lowerContent = content.toLowerCase();
     for (const [oldSchema, newSchema] of moved) {
-        const escapedSchema = escapeRegexp(oldSchema);
+        if (!lowerContent.includes(oldSchema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(oldSchema);
         // Pattern 1: quoted or unquoted schema name followed by dot (schema-qualified)
-        const dotPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
+        const dotPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)`, 'g');
         // Pattern 2: standalone schema name in known SQL contexts
         // Note: We don't use trailing \b because it fails after closing quotes
         // (both '"' and whitespace are non-word characters, so no boundary exists).
-        const standalonePattern = new RegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
+        const standalonePattern = cachedRegExp(`(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
             `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
         const dotMatches = content.match(dotPattern);
         const standaloneMatches = content.match(standalonePattern);
@@ -654,7 +661,7 @@ function validateNoUntransformedSchemas(content, schemaMapping) {
         if (totalMatches > 0) {
             const lines = content.split('\n');
             const locations = [];
-            const combinedPattern = new RegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
+            const combinedPattern = cachedRegExp(`(?:"${escapedSchema}"|\\b${escapedSchema})(?=\\.)|` +
                 `(?:ON\\s+SCHEMA\\s+|IN\\s+SCHEMA\\s+|CREATE\\s+SCHEMA\\s+|DROP\\s+SCHEMA\\s+(?:IF\\s+EXISTS\\s+)?|SET\\s+SCHEMA\\s+)` +
                 `(?:"${escapedSchema}"|\\b${escapedSchema}\\b)`, 'gi');
             for (let i = 0; i < lines.length; i++) {
@@ -899,6 +906,34 @@ function transformSchemasInContext(ctx, schemaMapping, result, visitorOptions) {
 function escapeRegexp(str) {
     return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
 }
+/**
+ * Compiling a pattern costs far more than running it, and the string-level
+ * passes below rebuild the same handful of per-schema patterns for every file
+ * they touch — on a large corpus that is hundreds of thousands of identical
+ * compiles. Patterns are keyed by source + flags and reused; each returned
+ * RegExp is stateful (`g`/`y` carry `lastIndex`), so callers must only use it
+ * with `String#replace`/`String#match`, which reset it, or reset it
+ * themselves, exactly as the throwaway instances required.
+ */
+const regExpCache = new Map();
+function cachedRegExp(source, flags) {
+    const key = `${flags}\u0000${source}`;
+    let re = regExpCache.get(key);
+    if (!re) {
+        re = new RegExp(source, flags);
+        regExpCache.set(key, re);
+    }
+    return re;
+}
+const escapeRegexpCache = new Map();
+function cachedEscapeRegexp(str) {
+    let escaped = escapeRegexpCache.get(str);
+    if (escaped === undefined) {
+        escaped = escapeRegexp(str);
+        escapeRegexpCache.set(str, escaped);
+    }
+    return escaped;
+}
 /**
  * Extract pgpm header comments from the beginning of SQL content.
  */
@@ -957,7 +992,7 @@ function transformComments(content, schemaMapping, result) {
             if (!newName)
                 continue;
             result.schemasFound.add(schema);
-            const pathPattern = new RegExp(`(schemas/)${escapeRegexp(schema)}(/|$)`, 'g');
+            const pathPattern = cachedRegExp(`(schemas/)${cachedEscapeRegexp(schema)}(/|$)`, 'g');
             const before = newPath;
             newPath = newPath.replace(pathPattern, `$1${newName}$2`);
             if (newPath !== before) {
@@ -974,15 +1009,20 @@ function transformComments(content, schemaMapping, result) {
 function transformVerifyCalls(content, schemaMapping, result) {
     const schemas = Array.from(schemaMapping.keys()).sort((a, b) => b.length - a.length);
     let newContent = content;
+    // The pattern needs the schema name spelled out, case-insensitively.
+    let lowerContent = content.toLowerCase();
     for (const schema of schemas) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const verifyPattern = new RegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
+        if (!lowerContent.includes(schema.toLowerCase()))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const verifyPattern = cachedRegExp(`(verify_(?:function|table|trigger|type|domain|view|index|constraint|schema|policy|table_grant|function_grant|sequence_grant|type_grant)\\s*\\(\\s*')${escapedSchema}(\\.|'\\s*\\))`, 'gi');
         const before = newContent;
         newContent = newContent.replace(verifyPattern, `$1${newName}$2`);
         if (newContent !== before) {
+            lowerContent = newContent.toLowerCase();
             result.schemasFound.add(schema);
             result.schemasTransformed.set(schema, newName);
         }
@@ -999,8 +1039,10 @@ function transformJsonStringValues(content, schemaMapping, result) {
         const newName = schemaMapping.get(schema);
         if (!newName)
             continue;
-        const escapedSchema = escapeRegexp(schema);
-        const jsonValuePattern = new RegExp(`(:")${escapedSchema}(")`, 'g');
+        if (!newContent.includes(schema))
+            continue;
+        const escapedSchema = cachedEscapeRegexp(schema);
+        const jsonValuePattern = cachedRegExp(`(:")${escapedSchema}(")`, 'g');
         const before = newContent;
         newContent = newContent.replace(jsonValuePattern, `$1${newName}$2`);
         if (newContent !== before) {