Fix NULL being appended to SQL statements with no interpolations (#341)

The zip function from es-toolkit pads arrays of different lengths with
undefined. Since template literals always have one more fragment than
values, when there were no interpolated values, zip would pair the single
fragment with undefined, which then got converted to "NULL".

Extracted a processTemplateParts helper that properly handles the template
literal structure by pairing each value with its preceding fragment and
appending the final fragment separately.

Co-authored-by: Claude Opus 4.5 <noreply@anthropic.com>

Author: rsslldnphy

packages/sql/src/sql.test.ts

@@ -24,6 +24,12 @@ describe("sql", () => {
         expect(statement.values).toEqual([]);
     });
 
+    test("interpolating undefined adds it as null rather than as a parameter", () => {
+        const statement = sql`SELECT ${undefined} FROM dual`;
+        expect(statement.text).toEqual("SELECT NULL FROM dual");
+        expect(statement.values).toEqual([]);
+    });
+
     test("interpolating true and false adds them literally rather than as a parameter", () => {
         const statement = sql`SELECT ${true}, ${false} FROM dual`;
         expect(statement.text).toEqual("SELECT TRUE, FALSE FROM dual");

packages/sql/src/sql.ts

@@ -17,7 +17,6 @@
  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  */
-import { zip } from "es-toolkit";
 import pg from "pg";
 import { format } from "sql-formatter";
 import { ZodType, z } from "zod";
@@ -42,25 +41,43 @@ const joinFragments = (
     };
 };
 
+/**
+ * Process template literal fragments and values into an ExpandedFragment.
+ * Template literals always have one more fragment than values, so we pair
+ * each value with its preceding fragment, then append the final fragment.
+ */
+const processTemplateParts = (
+    fragments: readonly string[],
+    values: readonly unknown[],
+): ExpandedFragment => {
+    const fragmentsCopy = [...fragments];
+    const lastFragment = fragmentsCopy.pop()!;
+    const pairs = fragmentsCopy.map(
+        (frag, i) => [frag, values[i]] as [string, unknown],
+    );
+
+    const result = pairs
+        .map(expandFragment)
+        .reduce(joinFragments, { text: [""], values: [] });
+
+    result.text[result.text.length - 1]! += lastFragment;
+    return result;
+};
+
 const expandFragment = ([fragment, value]: [
     string,
     unknown,
 ]): ExpandedFragment => {
     if (value === undefined) {
-        return { text: [fragment], values: [] };
+        return { text: [fragment + "NULL"], values: [] };
     } else if (value === null) {
         return { text: [fragment + "NULL"], values: [] };
     } else if (value === true) {
         return { text: [fragment + "TRUE"], values: [] };
     } else if (value === false) {
         return { text: [fragment + "FALSE"], values: [] };
     } else if (value instanceof SQLStatement) {
-        const expanded = zip(value._text, value._values)
-            .map(expandFragment)
-            .reduce(joinFragments, {
-                text: [""],
-                values: [],
-            });
+        const expanded = processTemplateParts(value._text, value._values);
         return {
             text: [fragment + expanded.text[0]!, ...expanded.text.slice(1)],
             values: [...expanded.values],
@@ -126,10 +143,8 @@ function sql<ResultType extends pg.QueryResultRow = pg.QueryResultRow>(
         return (fragments, ...values) =>
             sql<ResultType>(fragments, ...values).withSchema(fragmentsOrSchema);
     }
-    const result = zip(fragmentsOrSchema, values)
-        .map(expandFragment)
-        .reduce(joinFragments, { text: [""], values: [] });
 
+    const result = processTemplateParts(fragmentsOrSchema, values);
     return new SQLStatement<ResultType>(result.text, result.values);
 }