agentic-qe 3.6.14 → 3.6.15

package/v3/dist/mcp/bundle.js

@@ -38669,7 +38669,7 @@ var BaseTestGenerator = class _BaseTestGenerator {
     for (const [typeKey, generator] of _BaseTestGenerator.TYPE_VALUE_TABLE) {
       if (type.includes(typeKey)) return generator();
     }
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    return `{} /* TODO: provide ${param.name}: ${param.type || "unknown"} */`;
   }
   /**
    * Generate test cases for a function based on its signature
@@ -38682,21 +38682,46 @@ var BaseTestGenerator = class _BaseTestGenerator {
     const testCases = [];
     const validParams = fn.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>";
     testCases.push({
       description: "should handle valid input correctly",
       type: "happy-path",
-      action: `const result = ${fnCall};`,
-      assertion: "expect(result).toBeDefined();"
+      action: isVoid ? `${fnCall};` : `const result = ${fnCall};`,
+      assertion: isVoid ? `// void function \u2014 no return value to assert` : "expect(result).toBeDefined();"
     });
+    const bodyText = fn.body || "";
+    const hasExplicitThrow = /\bthrow\b/.test(bodyText) || /\bvalidat/i.test(bodyText);
     for (const param of fn.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = fn.parameters.map((p74) => p74.name === param.name ? "undefined" : this.generateTestValue(p74)).join(", ");
-        testCases.push({
-          description: `should handle undefined ${param.name}`,
-          type: "error-handling",
-          action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
-          assertion: "expect(action).toThrow();"
-        });
+        if (hasExplicitThrow) {
+          testCases.push({
+            description: `should handle undefined ${param.name}`,
+            type: "error-handling",
+            action: fn.isAsync ? `const action = async () => await ${fn.name}(${paramsWithUndefined});` : `const action = () => ${fn.name}(${paramsWithUndefined});`,
+            assertion: "expect(action).toThrow();"
+          });
+        } else {
+          const undefinedCall = fn.isAsync ? `await ${fn.name}(${paramsWithUndefined})` : `${fn.name}(${paramsWithUndefined})`;
+          testCases.push({
+            description: `should handle undefined ${param.name}`,
+            type: "edge-case",
+            action: fn.isAsync ? `let threw = false;
+    try {
+      await ${fn.name}(${paramsWithUndefined});
+    } catch (e) {
+      threw = true;
+      expect(e).toBeInstanceOf(Error);
+    }` : `let threw = false;
+    try {
+      ${fn.name}(${paramsWithUndefined});
+    } catch (e) {
+      threw = true;
+      expect(e).toBeInstanceOf(Error);
+    }`,
+            assertion: `expect(true).toBe(true); // function either handles undefined or throws TypeError`
+          });
+        }
       }
       testCases.push(...this.generateBoundaryTestCases(fn, param));
     }
@@ -38716,32 +38741,48 @@ var BaseTestGenerator = class _BaseTestGenerator {
   generateBoundaryTestCases(fn, param) {
     const testCases = [];
     const type = param.type?.toLowerCase() || "";
+    const wrapBoundaryAction = (call, isAsync) => {
+      if (isAsync) {
+        return `try {
+      const result = await ${call};
+      expect(result).toBeDefined();
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }`;
+      }
+      return `try {
+      const result = ${call};
+      expect(result).toBeDefined();
+    } catch (e) {
+      expect(e).toBeInstanceOf(Error);
+    }`;
+    };
     if (type.includes("string")) {
       const paramsWithEmpty = fn.parameters.map((p74) => p74.name === param.name ? "''" : this.generateTestValue(p74)).join(", ");
-      const emptyCall = fn.isAsync ? `await ${fn.name}(${paramsWithEmpty})` : `${fn.name}(${paramsWithEmpty})`;
+      const emptyCall = `${fn.name}(${paramsWithEmpty})`;
       testCases.push({
         description: `should handle empty string for ${param.name}`,
         type: "boundary",
-        action: `const result = ${emptyCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(emptyCall, fn.isAsync),
+        assertion: ""
       });
     }
     if (type.includes("number")) {
       const paramsWithZero = fn.parameters.map((p74) => p74.name === param.name ? "0" : this.generateTestValue(p74)).join(", ");
-      const zeroCall = fn.isAsync ? `await ${fn.name}(${paramsWithZero})` : `${fn.name}(${paramsWithZero})`;
+      const zeroCall = `${fn.name}(${paramsWithZero})`;
       testCases.push({
         description: `should handle zero for ${param.name}`,
         type: "boundary",
-        action: `const result = ${zeroCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(zeroCall, fn.isAsync),
+        assertion: ""
       });
       const paramsWithNegative = fn.parameters.map((p74) => p74.name === param.name ? "-1" : this.generateTestValue(p74)).join(", ");
-      const negativeCall = fn.isAsync ? `await ${fn.name}(${paramsWithNegative})` : `${fn.name}(${paramsWithNegative})`;
+      const negativeCall = `${fn.name}(${paramsWithNegative})`;
       testCases.push({
         description: `should handle negative value for ${param.name}`,
         type: "edge-case",
-        action: `const result = ${negativeCall};`,
-        assertion: "expect(result).toBeDefined();"
+        action: wrapBoundaryAction(negativeCall, fn.isAsync),
+        assertion: ""
       });
     }
     if (type.includes("[]") || type.includes("array")) {
@@ -38839,24 +38880,31 @@ ${importStatement}
 `;
     if (dependencies && dependencies.imports.length > 0) {
       const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
-      testCode += `
+      const externalDeps = dependencies.imports.filter((dep) => !dep.startsWith("."));
+      if (externalDeps.length > 0) {
+        testCode += `
 // Auto-generated mocks from Knowledge Graph dependency analysis
 `;
-      for (const dep of dependencies.imports.slice(0, 10)) {
-        const depName = dep.split("/").pop()?.replace(/[^a-zA-Z0-9_]/g, "_") || dep;
-        testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
+        for (const dep of externalDeps.slice(0, 10)) {
+          testCode += `${this.framework === "vitest" ? "vi" : "jest"}.mock('${dep}', () => ({ default: ${mockFn} }));
 `;
-      }
-      testCode += `
+        }
+        testCode += `
+`;
+      } else {
+        testCode += `
 `;
+      }
     } else {
       testCode += `
 `;
     }
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       testCode += this.generateFunctionTests(fn, testType);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       testCode += this.generateClassTests(cls, testType);
     }
     return testCode;
@@ -38943,24 +38991,52 @@ ${importStatement}
     const validParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const methodCall = method.isAsync ? `await instance.${method.name}(${validParams})` : `instance.${method.name}(${validParams})`;
     const asyncPrefix = method.isAsync ? "async " : "";
+    const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
     code += `    it('should execute successfully', ${asyncPrefix}() => {
 `;
-    code += `      const result = ${methodCall};
+    if (isVoid) {
+      code += `      ${methodCall};
 `;
-    code += `      expect(result).toBeDefined();
+      code += `      // void return \u2014 no assertion on result needed
 `;
+    } else {
+      code += `      const result = ${methodCall};
+`;
+      code += `      expect(result).toBeDefined();
+`;
+    }
     code += `    });
 `;
+    const methodBody = method.body || "";
+    const methodThrows = /\bthrow\b/.test(methodBody) || /\bvalidat/i.test(methodBody);
     for (const param of method.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = method.parameters.map((p74) => p74.name === param.name ? "undefined as any" : this.generateTestValue(p74)).join(", ");
-        code += `
-    it('should handle invalid ${param.name}', () => {
+        if (methodThrows) {
+          code += `
+    it('should handle invalid ${param.name}', ${asyncPrefix}() => {
 `;
-        code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();
+          code += `      expect(() => instance.${method.name}(${paramsWithUndefined})).toThrow();
 `;
-        code += `    });
+          code += `    });
+`;
+        } else {
+          code += `
+    it('should handle undefined ${param.name}', ${asyncPrefix}() => {
+`;
+          code += `      try {
+`;
+          code += `        ${method.isAsync ? "await " : ""}instance.${method.name}(${paramsWithUndefined});
+`;
+          code += `      } catch (e) {
+`;
+          code += `        expect(e).toBeInstanceOf(Error);
+`;
+          code += `      }
+`;
+          code += `    });
 `;
+        }
       }
     }
     code += `  });
@@ -38980,12 +39056,15 @@ ${importStatement}
     let mockDeclarations = "";
     if (dependencies && dependencies.imports.length > 0) {
       const mockFn = this.framework === "vitest" ? "vi.fn()" : "jest.fn()";
-      mockDeclarations += `
+      const externalDeps = dependencies.imports.filter((dep) => !dep.startsWith("."));
+      if (externalDeps.length > 0) {
+        mockDeclarations += `
 // Auto-generated mocks from Knowledge Graph dependency analysis
 `;
-      for (const dep of dependencies.imports.slice(0, 10)) {
-        mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
+        for (const dep of externalDeps.slice(0, 10)) {
+          mockDeclarations += `${this.mockUtil}.mock('${dep}', () => ({ default: ${mockFn} }));
 `;
+        }
       }
     }
     let similarityComment = "";
@@ -39262,10 +39341,11 @@ var MochaGenerator = class extends BaseTestGenerator {
     const importStatement = this.generateImportStatement(exports, importPath, moduleName);
     let sinonImport = "";
     let stubSetup = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const externalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (externalDeps.length > 0) {
       sinonImport = `import sinon from 'sinon';
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
+      const depsToMock = externalDeps.slice(0, 5);
       stubSetup += `  // Auto-generated stubs from Knowledge Graph dependency analysis
 `;
       stubSetup += `  let stubs;
@@ -39298,10 +39378,12 @@ ${sinonImport}${importStatement}
 
 describe('${moduleName} - ${testType} tests', function() {
 ${stubSetup}`;
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       code += this.generateFunctionTests(fn, testType);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       code += this.generateClassTests(cls, testType);
     }
     code += `});
@@ -39314,26 +39396,52 @@ ${stubSetup}`;
   generateFunctionTests(fn, _testType) {
     const validParams = fn.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
     const fnCall = fn.isAsync ? `await ${fn.name}(${validParams})` : `${fn.name}(${validParams})`;
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>";
     let code = `  describe('${fn.name}', function() {
 `;
     code += `    it('should handle valid input', ${fn.isAsync ? "async " : ""}function() {
 `;
-    code += `      const result = ${fnCall};
+    if (isVoid) {
+      code += `      ${fnCall};
+`;
+    } else {
+      code += `      const result = ${fnCall};
 `;
-    code += `      expect(result).to.not.be.undefined;
+      code += `      expect(result).to.not.be.undefined;
 `;
+    }
     code += `    });
 `;
+    const bodyText = fn.body || "";
+    const hasExplicitThrow = /\bthrow\b/.test(bodyText) || /\bvalidat/i.test(bodyText);
     for (const param of fn.parameters) {
       if (!param.optional) {
         const paramsWithUndefined = fn.parameters.map((p74) => p74.name === param.name ? "undefined" : this.generateTestValue(p74)).join(", ");
-        code += `
+        if (hasExplicitThrow) {
+          code += `
     it('should handle undefined ${param.name}', function() {
 `;
-        code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
+          code += `      expect(function() { ${fn.name}(${paramsWithUndefined}); }).to.throw();
 `;
-        code += `    });
+          code += `    });
+`;
+        } else {
+          code += `
+    it('should handle undefined ${param.name}', function() {
+`;
+          code += `      try {
+`;
+          code += `        ${fn.name}(${paramsWithUndefined});
+`;
+          code += `      } catch (e) {
 `;
+          code += `        expect(e).to.be.instanceOf(Error);
+`;
+          code += `      }
+`;
+          code += `    });
+`;
+        }
       }
     }
     code += `  });
@@ -39367,13 +39475,19 @@ ${stubSetup}`;
     for (const method of cls.methods) {
       if (!method.name.startsWith("_")) {
         const methodParams = method.parameters.map((p74) => this.generateTestValue(p74)).join(", ");
+        const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
         code += `
     it('${method.name} should work', ${method.isAsync ? "async " : ""}function() {
 `;
-        code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+        if (isVoid) {
+          code += `      ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
 `;
-        code += `      expect(result).to.not.be.undefined;
+        } else {
+          code += `      const result = ${method.isAsync ? "await " : ""}instance.${method.name}(${methodParams});
+`;
+          code += `      expect(result).to.not.be.undefined;
 `;
+        }
         code += `    });
 `;
       }
@@ -39396,10 +39510,11 @@ ${stubSetup}`;
     let sinonImport = "";
     let stubSetup = "";
     let stubTeardown = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const stubExternalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (stubExternalDeps.length > 0) {
       sinonImport = `import sinon from 'sinon';
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
+      const depsToMock = stubExternalDeps.slice(0, 5);
       stubSetup += `
     // Auto-generated stubs from Knowledge Graph dependency analysis
 `;
@@ -39570,12 +39685,13 @@ var PytestGenerator = class extends BaseTestGenerator {
     const exports = this.extractExports(analysis.functions, analysis.classes);
     const pythonImport = importPath.replace(/\//g, ".").replace(/\.(ts|js)$/, "");
     const importStatement = exports.length > 0 ? `from ${pythonImport} import ${exports.join(", ")}` : `import ${pythonImport} as ${moduleName}`;
+    const externalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
     let mockImport = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    if (externalDeps.length > 0) {
       mockImport = `from unittest.mock import patch, MagicMock
 `;
     }
-    const depsToMock = dependencies?.imports.slice(0, 5) || [];
+    const depsToMock = externalDeps.slice(0, 5);
     const patchDecorators = depsToMock.map((dep) => {
       const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
       return `@patch('${depModule}')`;
@@ -39588,10 +39704,12 @@ class Test${this.pascalCase(moduleName)}:
     """${testType} tests for ${moduleName}"""
 
 `;
-    for (const fn of analysis.functions) {
+    const exportedFns = analysis.functions.filter((fn) => fn.isExported);
+    const exportedClasses = analysis.classes.filter((cls) => cls.isExported);
+    for (const fn of exportedFns) {
       code += this.generateFunctionTestsWithPatches(fn, testType, patchDecorators);
     }
-    for (const cls of analysis.classes) {
+    for (const cls of exportedClasses) {
       code += this.generateClassTests(cls, testType);
     }
     return code;
@@ -39611,15 +39729,22 @@ class Test${this.pascalCase(moduleName)}:
     const allParams = mockParams ? `self, ${mockParams}` : "self";
     const patchPrefix = patchDecorators.map((d74) => `    ${d74}
 `).join("");
+    const isVoid = fn.returnType === "void" || fn.returnType === "Promise<void>" || fn.returnType === "None";
     let code = `${patchPrefix}    def test_${fn.name}_valid_input(${allParams}):
 `;
     code += `        """Test ${fn.name} with valid input"""
 `;
-    code += `        result = ${fn.name}(${validParams})
+    if (isVoid) {
+      code += `        ${fn.name}(${validParams})  # void function
+
+`;
+    } else {
+      code += `        result = ${fn.name}(${validParams})
 `;
-    code += `        assert result is not None
+      code += `        assert result is not None
 
 `;
+    }
     for (const param of fn.parameters) {
       if (!param.optional && param.type?.includes("str")) {
         code += `${patchPrefix}    def test_${fn.name}_empty_${param.name}(${allParams}):
@@ -39662,13 +39787,20 @@ class Test${cls.name}:
     for (const method of cls.methods) {
       if (!method.name.startsWith("_")) {
         const methodParams = method.parameters.map((p74) => this.generatePythonTestValue(p74)).join(", ");
+        const isVoid = method.returnType === "void" || method.returnType === "Promise<void>";
         code += `    def test_${method.name}(self, instance):
 `;
-        code += `        result = instance.${method.name}(${methodParams})
+        if (isVoid) {
+          code += `        instance.${method.name}(${methodParams})
+
 `;
-        code += `        assert result is not None
+        } else {
+          code += `        result = instance.${method.name}(${methodParams})
+`;
+          code += `        assert result is not None
 
 `;
+        }
       }
     }
     return code;
@@ -39686,11 +39818,11 @@ class Test${cls.name}:
     const asyncDef = isAsync ? "async def" : "def";
     let mockImports = "";
     let mockPatches = "";
-    if (dependencies && dependencies.imports.length > 0) {
+    const stubExternalDeps = dependencies?.imports.filter((dep) => !dep.startsWith(".")) || [];
+    if (stubExternalDeps.length > 0) {
       mockImports = `from unittest.mock import patch, MagicMock
 `;
-      const depsToMock = dependencies.imports.slice(0, 5);
-      for (const dep of depsToMock) {
+      for (const dep of stubExternalDeps.slice(0, 5)) {
         const depModule = dep.replace(/\//g, ".").replace(/\.py$/, "");
         mockPatches += `    @patch('${depModule}')
 `;
@@ -41331,12 +41463,18 @@ ${sourceCode}
       const callees = [];
       const callers = [];
       const tsImports = sourceContent.matchAll(/(?:import|from)\s+['"]([^'"]+)['"]/g);
-      const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
       for (const match of tsImports) {
         imports.push(match[1]);
       }
-      for (const match of pyImports) {
-        imports.push(match[1] || match[2]);
+      const isPython = filePath.endsWith(".py");
+      if (isPython) {
+        const pyImports = sourceContent.matchAll(/(?:^|\n)\s*(?:from\s+(\S+)\s+import|import\s+(\S+))/g);
+        for (const match of pyImports) {
+          const mod = match[1] || match[2];
+          if (mod && /^[a-zA-Z_][\w.]*$/.test(mod)) {
+            imports.push(mod);
+          }
+        }
       }
       const normalizedPath = filePath.replace(/\\/g, "/");
       const baseName = normalizedPath.split("/").pop()?.replace(/\.(ts|js|tsx|jsx|py)$/, "") || "";
@@ -42365,7 +42503,7 @@ var PatternMatcherService = class _PatternMatcherService {
         return template.replace("{{name}}", param.name);
       }
     }
-    return `mock${param.name.charAt(0).toUpperCase() + param.name.slice(1)}`;
+    return `{} /* TODO: provide ${param.name}: ${param.type || "unknown"} */`;
   }
   /**
    * Estimate number of branches from cyclomatic complexity

package/v3/dist/shared/sql-safety.d.ts

@@ -19,6 +19,9 @@ export declare function validateTableName(tableName: string): string;
  * Validate a PostgreSQL identifier (table or column name) against a strict regex.
  * Prevents SQL injection via dynamically interpolated identifiers (CWE-89).
  *
+ * Supports schema-qualified names like "aqe.qe_patterns" by validating each
+ * dot-separated part independently.
+ *
  * @param name - The identifier to validate
  * @returns The validated identifier string if valid
  * @throws {Error} If the identifier contains invalid characters or format

package/v3/dist/shared/sql-safety.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sql-safety.d.ts","sourceRoot":"","sources":["../../src/shared/sql-safety.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAuB9B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK3D;AAQD;;;;;;;GAOG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOvD"}
+{"version":3,"file":"sql-safety.d.ts","sourceRoot":"","sources":["../../src/shared/sql-safety.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,eAAO,MAAM,mBAAmB,aAuB9B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,iBAAiB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAK3D;AAQD;;;;;;;;;;GAUG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAgBvD"}

package/v3/dist/shared/sql-safety.js

@@ -52,13 +52,23 @@ const IDENTIFIER_REGEX = /^[a-z_][a-z0-9_]{0,62}$/;
  * Validate a PostgreSQL identifier (table or column name) against a strict regex.
  * Prevents SQL injection via dynamically interpolated identifiers (CWE-89).
  *
+ * Supports schema-qualified names like "aqe.qe_patterns" by validating each
+ * dot-separated part independently.
+ *
  * @param name - The identifier to validate
  * @returns The validated identifier string if valid
  * @throws {Error} If the identifier contains invalid characters or format
  */
 export function validateIdentifier(name) {
-    if (!IDENTIFIER_REGEX.test(name)) {
-        throw new Error(`Invalid SQL identifier: "${name}" does not match pattern ${IDENTIFIER_REGEX}`);
+    // Handle schema-qualified names (e.g., "aqe.qe_patterns")
+    const parts = name.split('.');
+    if (parts.length > 2) {
+        throw new Error(`Invalid SQL identifier: "${name}" has too many parts (max: schema.table)`);
+    }
+    for (const part of parts) {
+        if (!IDENTIFIER_REGEX.test(part)) {
+            throw new Error(`Invalid SQL identifier: "${name}" — part "${part}" does not match pattern ${IDENTIFIER_REGEX}`);
+        }
     }
     return name;
 }

package/v3/dist/shared/sql-safety.js.map

@@ -1 +1 @@
-{"version":3,"file":"sql-safety.js","sourceRoot":"","sources":["../../src/shared/sql-safety.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IACzC,qBAAqB;IACrB,gBAAgB,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa;IACtD,cAAc;IACd,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,sBAAsB;IAClE,uBAAuB;IACvB,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB;IAClE,oBAAoB;IACpB,aAAa,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,iBAAiB;IAC7E,mBAAmB;IACnB,YAAY,EAAE,mBAAmB,EAAE,gBAAgB;IACnD,gBAAgB;IAChB,kBAAkB,EAAE,gBAAgB,EAAE,sBAAsB;IAC5D,eAAe,EAAE,wBAAwB,EAAE,qBAAqB;IAChE,cAAc;IACd,eAAe;IACf,uBAAuB;IACvB,eAAe,EAAE,kBAAkB,EAAE,mBAAmB;IACxD,cAAc;IACd,UAAU;IACV,oBAAoB;IACpB,qBAAqB,EAAE,uBAAuB,EAAE,0BAA0B;IAC1E,8BAA8B,EAAE,4BAA4B;CAC7D,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,wBAAwB,SAAS,2BAA2B,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAEnD;;;;;;;GAOG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;QACjC,MAAM,IAAI,KAAK,CACb,4BAA4B,IAAI,4BAA4B,gBAAgB,EAAE,CAC/E,CAAC;IACJ,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}
+{"version":3,"file":"sql-safety.js","sourceRoot":"","sources":["../../src/shared/sql-safety.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH;;;GAGG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,GAAG,CAAC;IACzC,qBAAqB;IACrB,gBAAgB,EAAE,UAAU,EAAE,SAAS,EAAE,aAAa;IACtD,cAAc;IACd,YAAY,EAAE,cAAc,EAAE,YAAY,EAAE,sBAAsB;IAClE,uBAAuB;IACvB,eAAe,EAAE,eAAe,EAAE,cAAc,EAAE,gBAAgB;IAClE,oBAAoB;IACpB,aAAa,EAAE,uBAAuB,EAAE,kBAAkB,EAAE,iBAAiB;IAC7E,mBAAmB;IACnB,YAAY,EAAE,mBAAmB,EAAE,gBAAgB;IACnD,gBAAgB;IAChB,kBAAkB,EAAE,gBAAgB,EAAE,sBAAsB;IAC5D,eAAe,EAAE,wBAAwB,EAAE,qBAAqB;IAChE,cAAc;IACd,eAAe;IACf,uBAAuB;IACvB,eAAe,EAAE,kBAAkB,EAAE,mBAAmB;IACxD,cAAc;IACd,UAAU;IACV,oBAAoB;IACpB,qBAAqB,EAAE,uBAAuB,EAAE,0BAA0B;IAC1E,8BAA8B,EAAE,4BAA4B;CAC7D,CAAC,CAAC;AAEH;;;GAGG;AACH,MAAM,UAAU,iBAAiB,CAAC,SAAiB;IACjD,IAAI,CAAC,mBAAmB,CAAC,GAAG,CAAC,SAAS,CAAC,EAAE,CAAC;QACxC,MAAM,IAAI,KAAK,CAAC,wBAAwB,SAAS,2BAA2B,CAAC,CAAC;IAChF,CAAC;IACD,OAAO,SAAS,CAAC;AACnB,CAAC;AAED;;;GAGG;AACH,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAEnD;;;;;;;;;;GAUG;AACH,MAAM,UAAU,kBAAkB,CAAC,IAAY;IAC7C,0DAA0D;IAC1D,MAAM,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;QACrB,MAAM,IAAI,KAAK,CACb,4BAA4B,IAAI,0CAA0C,CAC3E,CAAC;IACJ,CAAC;IACD,KAAK,MAAM,IAAI,IAAI,KAAK,EAAE,CAAC;QACzB,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC;YACjC,MAAM,IAAI,KAAK,CACb,4BAA4B,IAAI,aAAa,IAAI,4BAA4B,gBAAgB,EAAE,CAChG,CAAC;QACJ,CAAC;IACH,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC"}

package/v3/dist/sync/cloud/postgres-writer.d.ts

@@ -73,7 +73,12 @@ export declare class PostgresWriter implements CloudWriter {
      */
     private serializeValue;
     /**
-     * Infer conflict columns from table name
+     * Check if a column is a JSONB column
+     */
+    private isJsonbColumn;
+    /**
+     * Infer conflict columns from table name and available columns.
+     * Only returns columns if the target table is known to have a matching unique constraint.
      */
     private inferConflictColumns;
     /**

package/v3/dist/sync/cloud/postgres-writer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postgres-writer.d.ts","sourceRoot":"","sources":["../../../src/sync/cloud/postgres-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AASzD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0BAA0B;IAC1B,KAAK,EAAE,WAAW,CAAC;IAEnB,qBAAqB;IACrB,aAAa,EAAE,aAAa,CAAC;IAE7B,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,+BAA+B;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAYD;;GAEG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,oBAAoB;IAIxC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IA4C9B;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQvC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ7B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ/B;;OAEG;IACG,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IA8BtF;;OAEG;YACW,WAAW;IAyDzB;;OAEG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7D;;OAEG;IACG,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAQ7D;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACH,OAAO,CAAC,cAAc;IA0EtB;;OAEG;IACH,OAAO,CAAC,oBAAoB;IA4B5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAezB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAEjF"}
+{"version":3,"file":"postgres-writer.d.ts","sourceRoot":"","sources":["../../../src/sync/cloud/postgres-writer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAE,WAAW,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,kBAAkB,CAAC;AAChF,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AAczD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACnC,0BAA0B;IAC1B,KAAK,EAAE,WAAW,CAAC;IAEnB,qBAAqB;IACrB,aAAa,EAAE,aAAa,CAAC;IAE7B,2BAA2B;IAC3B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB,+BAA+B;IAC/B,iBAAiB,CAAC,EAAE,MAAM,CAAC;CAC5B;AAYD;;GAEG;AACH,qBAAa,cAAe,YAAW,WAAW;IAChD,OAAO,CAAC,MAAM,CAAyB;IACvC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAuB;IAC9C,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,SAAS,CAAS;gBAEd,MAAM,EAAE,oBAAoB;IAIxC;;OAEG;IACG,OAAO,IAAI,OAAO,CAAC,IAAI,CAAC;IAiD9B;;OAEG;IACG,gBAAgB,IAAI,OAAO,CAAC,IAAI,CAAC;IAQvC;;OAEG;IACG,MAAM,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ7B;;OAEG;IACG,QAAQ,IAAI,OAAO,CAAC,IAAI,CAAC;IAQ/B;;OAEG;IACG,MAAM,CAAC,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,OAAO,EAAE,CAAC,EAAE,EAAE,OAAO,CAAC,EAAE,aAAa,GAAG,OAAO,CAAC,MAAM,CAAC;IAoDtF;;OAEG;YACW,WAAW;IA0DzB;;OAEG;IACG,OAAO,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,IAAI,CAAC;IAO7D;;OAEG;IACG,KAAK,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,OAAO,EAAE,GAAG,OAAO,CAAC,CAAC,EAAE,CAAC;IAQ7D;;OAEG;IACG,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC;IAa5B;;OAEG;IACH,OAAO,CAAC,cAAc;IA4FtB;;OAEG;IACH,OAAO,CAAC,aAAa;IAQrB;;;OAGG;IACH,OAAO,CAAC,oBAAoB;IAyC5B;;OAEG;IACH,OAAO,CAAC,gBAAgB;CAezB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,oBAAoB,GAAG,cAAc,CAEjF"}