@casekit/sql 0.0.0-20250322230249

package/build/index.d.ts

@@ -0,0 +1 @@
+export { SQLStatement, sql } from "./sql.js";

package/build/index.js

@@ -0,0 +1,3 @@
+/* v8 ignore start */
+export { SQLStatement, sql } from "./sql.js";
+/* v8 ignore stop */

package/build/sql.d.ts

@@ -0,0 +1,94 @@
+import pg from "pg";
+import { ZodSchema, z } from "zod";
+type SQLStatementTaggedTemplateLiteral<ResultType extends pg.QueryResultRow = pg.QueryResultRow> = (fragments: TemplateStringsArray, ...values: readonly unknown[]) => SQLStatement<ResultType>;
+/**
+ * @function
+ * Tagged template literal that safely parameterizes an interpolated SQL query.
+ * @example
+ * pg.query(sql`SELECT * FROM users WHERE id = ${userId}`)
+ * // is the equivalent of
+ * pg.query("SELECT * FROM users WHERE id = $1", [userId])
+ *
+ * It's also possible to pass a zod schema to the sql tag
+ * to validate and type the result:
+ *
+ * const userSchema = sql(z.object({ id: z.number(), name: z.string() }))`
+ *    SELECT id, name FROM users WHERE id = ${userId}
+ * `;
+ */
+declare function sql<ResultType extends pg.QueryResultRow = pg.QueryResultRow>(fragments: TemplateStringsArray, ...values: readonly unknown[]): SQLStatement<ResultType>;
+declare function sql<ResultType extends pg.QueryResultRow = pg.QueryResultRow>(schema: z.ZodSchema<ResultType>): SQLStatementTaggedTemplateLiteral<ResultType>;
+declare namespace sql {
+    var array: (values: readonly unknown[]) => SQLValueArray;
+    var ident: (value: string) => SQLStatement<pg.QueryResultRow>;
+    var literal: (value: string) => SQLStatement<pg.QueryResultRow>;
+    var join: (values: SQLStatement[], separator?: string) => SQLStatement<pg.QueryResultRow>;
+    var value: (value: unknown) => SQLValueArray | SQLStatement<pg.QueryResultRow>;
+}
+/**
+ * Class representing a SQL statement created by the `sql` template tag.
+ * Stores an array of text fragments and an array of values to interpolate,
+ * such that the correct parameter placeholders can be generated when
+ * the query is complete.
+ * @ignore
+ * NB. The SQLStatement can be parameterized with a type parameter `ResultType' for the type of the row
+ * it returns. This isn't used in the class itself, but is used by the `orm.query` method
+ * when the SQLStatement is passed to it to determine the type of the row. However, if the
+ * call to orm.query is itself parameterized with a type, that type will take precedence.
+ */
+export declare class SQLStatement<ResultType extends pg.QueryResultRow = pg.QueryResultRow> {
+    readonly _text: string[];
+    readonly _values: unknown[];
+    protected _schema?: ZodSchema<ResultType>;
+    constructor(text?: readonly string[] | string, values?: readonly unknown[]);
+    /**
+     * This accessor is called by node-postgres when passed as a query,
+     * allowing us to pass a SQLStatement to `client.query` directly.
+     */
+    get text(): string;
+    /**
+     * This accessor is called by node-postgres when passed as a query,
+     * allowing us to pass a SQLStatement to `client.query` directly.
+     *
+     * By default, when passed an array as a value, we auto-expand it into
+     * multiple values. Because there are some cases where we actually want to pass
+     * an array as a single value, we have a SQLValueArray class to indicate this.
+     * This class prevents the array from being expanded into multiple values.
+     *
+     * We do it this way round because it's more common to want to expand arrays
+     * than to want to pass them as a single value.
+     */
+    get values(): unknown[];
+    /**
+     * Get the pretty-printed version of the SQL statement.
+     * We don't automatically apply this for two reasons:
+     * 1. Speed
+     * 2. It increases the potential attack surface area
+     */
+    get pretty(): string;
+    append(fragments: TemplateStringsArray, ...values: unknown[]): this;
+    /**
+     * Allows appending other SQLStatements onto this one, combining them.
+     * Mainly used internally. Mutates the SQLStatement and returns `this`.
+     */
+    push(...others: SQLStatement[]): this;
+    /**
+     * The Zod schema that will be used to parse and validate
+     * the results of the query when it is passed to `orm.query`.
+     */
+    get schema(): ZodSchema<ResultType> | undefined;
+    /**
+     * Assign a zod schema to this SQLStatement, which will be used to validate
+     * the result of the query when it is passed to `orm.query`.
+     */
+    withSchema<Schema extends ZodSchema>(schema: Schema): SQLStatement<z.infer<Schema>>;
+}
+/**
+ * A class to wrap an array value that we don't want
+ * to auto-expand into multiple parameters.
+ */
+export declare class SQLValueArray {
+    values: unknown[];
+    constructor(values: readonly unknown[]);
+}
+export { sql };

package/build/sql.js

@@ -0,0 +1,220 @@
+/**
+ * This file is heavily inspired by felixfbecker/node-sql-template-strings,
+ * which has the following licence:
+ *
+ * ISC License
+ * Copyright (c) 2016, Felix Frederick Becker
+ *
+ * Permission to use, copy, modify, and/or distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * 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 { z } from "zod";
+import { interleave } from "@casekit/toolbox";
+import { unindent } from "@casekit/unindent";
+const joinFragments = (x, y) => {
+    const initX = x.text.slice(0, -1);
+    const lastX = x.text[x.text.length - 1];
+    const tailY = y.text.slice(1);
+    const firstY = y.text[0];
+    return {
+        text: [...initX, lastX + firstY, ...tailY],
+        values: [...x.values, ...y.values],
+    };
+};
+const expandFragment = ([fragment, value]) => {
+    if (value === undefined) {
+        return { text: [fragment], 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: [],
+        });
+        return {
+            text: [fragment + expanded.text[0], ...expanded.text.slice(1)],
+            values: [...expanded.values],
+        };
+    }
+    else if (value.constructor.name === "SQLStatement") {
+        console.error("It looks like you have multiple versions of the SQLStatement class in memory. ");
+        console.error("This can happen if you have multiple versions of the @casekit/orm or @casekit/sql packages installed.");
+        console.error("Please ensure you only have one version of these packages installed, and that related @casekit/orm2-* packages are all at the same version.");
+        throw new Error("Multiple versions of SQLStatement class detected");
+    }
+    else if (Array.isArray(value) && value.length === 0) {
+        return { text: [fragment + "NULL"], values: [] };
+    }
+    else if (Array.isArray(value) && value.length > 0) {
+        return value
+            .map((v, i) => expandFragment([i === 0 ? "" : ", ", v]))
+            .reduce(joinFragments, { text: [fragment], values: [] });
+    }
+    else {
+        return { text: [fragment, ""], values: [value] };
+    }
+};
+function sql(fragmentsOrSchema, ...values) {
+    if (fragmentsOrSchema instanceof z.ZodSchema) {
+        return (fragments, ...values) => sql(fragments, ...values).withSchema(fragmentsOrSchema);
+    }
+    const result = zip(fragmentsOrSchema, values)
+        .map(expandFragment)
+        .reduce(joinFragments, { text: [""], values: [] });
+    return new SQLStatement(result.text, result.values);
+}
+/**
+ * Class representing a SQL statement created by the `sql` template tag.
+ * Stores an array of text fragments and an array of values to interpolate,
+ * such that the correct parameter placeholders can be generated when
+ * the query is complete.
+ * @ignore
+ * NB. The SQLStatement can be parameterized with a type parameter `ResultType' for the type of the row
+ * it returns. This isn't used in the class itself, but is used by the `orm.query` method
+ * when the SQLStatement is passed to it to determine the type of the row. However, if the
+ * call to orm.query is itself parameterized with a type, that type will take precedence.
+ */
+export class SQLStatement {
+    _text;
+    _values;
+    _schema;
+    constructor(text = [], values = []) {
+        this._text = typeof text === "string" ? [text] : [...text];
+        this._values = [...values];
+    }
+    // this weirdness deals with the case where we have multiple instantiations
+    // of this class, breaking instanceof. we want instanceof to work for
+    // any instantiation of this class in memory, so we encode a random
+    // uuid and override instanceof to check this in place of the usual check.
+    // see https://github.com/colinhacks/zod/issues/2241 for more info
+    // private static readonly __classId = Symbol.for(
+    //     "@casekit/orm/sql/SQLStatement-1C9E8AD8-4B55-41F0-95D0-934891ADB0C0",
+    // );
+    // public readonly __classId = SQLStatement.__classId;
+    // // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    // static [Symbol.hasInstance](obj: any) {
+    //     return (
+    //         // eslint-disable-next-line
+    //         !!obj && obj.__classId === SQLStatement.__classId
+    //     );
+    // }
+    /**
+     * This accessor is called by node-postgres when passed as a query,
+     * allowing us to pass a SQLStatement to `client.query` directly.
+     */
+    get text() {
+        // prettier-ignore
+        const text = this._text.reduce(// NOSONAR
+        (prev, curr, i) => prev + "$" + i.toString() + curr);
+        return unindent `${text}`;
+    }
+    /**
+     * This accessor is called by node-postgres when passed as a query,
+     * allowing us to pass a SQLStatement to `client.query` directly.
+     *
+     * By default, when passed an array as a value, we auto-expand it into
+     * multiple values. Because there are some cases where we actually want to pass
+     * an array as a single value, we have a SQLValueArray class to indicate this.
+     * This class prevents the array from being expanded into multiple values.
+     *
+     * We do it this way round because it's more common to want to expand arrays
+     * than to want to pass them as a single value.
+     */
+    get values() {
+        return this._values.map((v) => v instanceof SQLValueArray ? v.values : v);
+    }
+    /**
+     * Get the pretty-printed version of the SQL statement.
+     * We don't automatically apply this for two reasons:
+     * 1. Speed
+     * 2. It increases the potential attack surface area
+     */
+    get pretty() {
+        return format(this.text, { language: "postgresql", tabWidth: 4 });
+    }
+    append(fragments, ...values) {
+        return this.push(sql(fragments, ...values));
+    }
+    /**
+     * Allows appending other SQLStatements onto this one, combining them.
+     * Mainly used internally. Mutates the SQLStatement and returns `this`.
+     */
+    push(...others) {
+        for (const other of others) {
+            if (other._text.length === 0) {
+                // do nothing - statement is empty
+            }
+            else if (this._text.length === 0) {
+                this._text.push(...other._text);
+                this._values.push(...other._values);
+            }
+            else {
+                this._text[this._text.length - 1] += other._text[0];
+                this._text.push(...other._text.slice(1));
+                this._values.push(...other._values);
+            }
+        }
+        return this;
+    }
+    /**
+     * The Zod schema that will be used to parse and validate
+     * the results of the query when it is passed to `orm.query`.
+     */
+    get schema() {
+        return this._schema;
+    }
+    /**
+     * Assign a zod schema to this SQLStatement, which will be used to validate
+     * the result of the query when it is passed to `orm.query`.
+     */
+    withSchema(schema) {
+        const self = this;
+        self._schema = schema;
+        return self;
+    }
+}
+/**
+ * A class to wrap an array value that we don't want
+ * to auto-expand into multiple parameters.
+ */
+export class SQLValueArray {
+    values;
+    constructor(values) {
+        this.values = [...values];
+    }
+}
+const array = (values) => new SQLValueArray(values);
+const ident = (value) => new SQLStatement(pg.escapeIdentifier(value));
+const literal = (value) => new SQLStatement(pg.escapeLiteral(value));
+const value = (value) => Array.isArray(value) ? array(value) : sql `${value}`;
+const join = (values, separator = `, `) => {
+    return new SQLStatement("").push(...interleave(values, new SQLStatement(separator)));
+};
+sql.array = array;
+sql.ident = ident;
+sql.literal = literal;
+sql.join = join;
+sql.value = value;
+export { sql };

package/build/sql.test.d.ts

@@ -0,0 +1 @@
+export {};

package/build/sql.test.js

@@ -0,0 +1,273 @@
+import { describe, expect, test } from "vitest";
+import { z } from "zod";
+import { unindent } from "@casekit/unindent";
+import { SQLStatement, sql } from "./sql.js";
+describe("sql", () => {
+    test("simple string", () => {
+        const statement = sql `SELECT 1 FROM dual`;
+        expect(statement.text).toEqual("SELECT 1 FROM dual");
+        expect(statement.values).toEqual([]);
+    });
+    test("interpolating a variable", () => {
+        const statement = sql `SELECT ${1} FROM dual`;
+        expect(statement.text).toEqual("SELECT $1 FROM dual");
+        expect(statement.values).toEqual([1]);
+    });
+    test("interpolating null adds it literally rather than as a parameter", () => {
+        const statement = sql `SELECT ${null} 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");
+        expect(statement.values).toEqual([]);
+    });
+    test("interpolating multiple variables", () => {
+        const statement = sql `
+                SELECT title FROM posts
+                WHERE author = ${`Stewart Home`}
+                AND likes > ${10}
+            `;
+        expect(statement.text).toEqual(unindent `
+                SELECT title FROM posts
+                WHERE author = $1
+                AND likes > $2
+            `);
+        expect(statement.values).toEqual(["Stewart Home", 10]);
+    });
+    test("interpolating an array", () => {
+        const statement = sql `
+                SELECT title FROM posts
+                WHERE author IN (${["Stewart Home", "Kathy Acker"]})
+                AND likes > ${10}
+            `;
+        expect(statement.values).toEqual(["Stewart Home", "Kathy Acker", 10]);
+        expect(statement.text).toEqual(unindent `
+                SELECT title FROM posts
+                WHERE author IN ($1, $2)
+                AND likes > $3
+            `);
+    });
+    test("interpolating an array with no values", () => {
+        const statement = sql `
+                SELECT title FROM posts
+                WHERE author IN (${[]})
+                AND likes > ${10}
+            `;
+        expect(statement.text).toEqual(unindent `
+                SELECT title FROM posts
+                WHERE author IN (NULL)
+                AND likes > $1
+            `);
+        expect(statement.values).toEqual([10]);
+    });
+    test("interpolating a sql fragment", () => {
+        const subquery = sql `
+                SELECT id, title FROM posts
+                WHERE author = ${"J.G. Ballard"}
+            `;
+        const statement = sql `
+                SELECT u.username, p.title
+                FROM users u
+                WHERE u.favourite_post_id IN (${subquery}) p
+                AND u.signed_up_at < ${new Date("2021-01-01")}
+            `;
+        expect(statement.text).toEqual(unindent `
+                SELECT u.username, p.title
+                FROM users u
+                WHERE u.favourite_post_id IN (
+                SELECT id, title FROM posts
+                WHERE author = $1
+            ) p
+                AND u.signed_up_at < $2
+            `);
+        expect(statement.values).toEqual([
+            "J.G. Ballard",
+            new Date("2021-01-01"),
+        ]);
+    });
+    test("interpolating an array of SQLStatements", () => {
+        const fragments = [sql `${"axolotl"}::text`, sql `${"binturong"}`];
+        const statement = sql `
+                INSERT INTO animals (name) VALUES (${fragments})
+            `;
+        expect(statement.text).toEqual(unindent `
+                INSERT INTO animals (name) VALUES ($1::text, $2)
+            `);
+        expect(statement.values).toEqual(["axolotl", "binturong"]);
+    });
+    test("interpolating an mixed array of SQLStatements and scalar values", () => {
+        const fragments = [sql `${"axolotl"}::text`, 3, sql `${"binturong"}`];
+        const statement = sql `
+                INSERT INTO animals (name) VALUES (${fragments})
+            `;
+        expect(statement.text).toEqual(unindent `
+                INSERT INTO animals (name) VALUES ($1::text, $2, $3)
+            `);
+        expect(statement.values).toEqual(["axolotl", 3, "binturong"]);
+    });
+    test("interpolating multiple levels of nesting of SQLStatements", () => {
+        const fragments = [sql `${"axolotl"}::text`, 3, sql `${"binturong"}`];
+        const subquery1 = sql `
+            SELECT id, name FROM animals WHERE name IN (${fragments})
+        `;
+        const subquery2 = sql `
+            SELECT id FROM animals
+            WHERE id IN (${subquery1})
+            AND name IN (${fragments})
+        `;
+        const statement = sql `
+            SELECT id FROM animals
+            WHERE id IN (${subquery2})
+        `;
+        expect(statement.pretty).toEqual(unindent `
+            SELECT
+                id
+            FROM
+                animals
+            WHERE
+                id IN (
+                    SELECT
+                        id
+                    FROM
+                        animals
+                    WHERE
+                        id IN (
+                            SELECT
+                                id,
+                                name
+                            FROM
+                                animals
+                            WHERE
+                                name IN ($1::text, $2, $3)
+                        )
+                        AND name IN ($4::text, $5, $6)
+                )
+        `);
+        expect(statement.values).toEqual([
+            "axolotl",
+            3,
+            "binturong",
+            "axolotl",
+            3,
+            "binturong",
+        ]);
+    });
+});
+describe("sql.array", () => {
+    test("interpolating an array without expanding it", () => {
+        const statement = sql `
+                INSERT INTO animals (name) VALUES (${sql.array(["axolotl", "binturong"])})
+            `;
+        expect(statement.text).toEqual(unindent `
+                INSERT INTO animals (name) VALUES ($1)
+            `);
+        expect(statement.values).toEqual([["axolotl", "binturong"]]);
+    });
+});
+describe("sql.ident", () => {
+    test("interpolating a simple identifier", () => {
+        const statement = sql `
+                SELECT ${sql.ident("title")} FROM posts
+            `;
+        expect(statement.text).toEqual(unindent `
+                SELECT "title" FROM posts
+            `);
+        expect(statement.values).toEqual([]);
+    });
+    test("interpolating a mixed-case identifier", () => {
+        const statement = sql `
+                SELECT ${sql.ident("createdBy")} FROM posts
+            `;
+        expect(statement.text).toEqual(unindent `
+                SELECT "createdBy" FROM posts
+            `);
+        expect(statement.values).toEqual([]);
+    });
+    test("interpolating a malicious identifier", () => {
+        const statement = sql `
+                SELECT ${sql.ident("'; delete from users;\"delete from posts")} FROM posts
+            `;
+        expect(statement.text).toEqual(unindent `
+                SELECT "'; delete from users;""delete from posts" FROM posts
+            `);
+        expect(statement.values).toEqual([]);
+    });
+});
+describe("sql.literal", () => {
+    test("interpolating a simple literal", () => {
+        const statement = sql `
+            SELECT * FROM posts WHERE title = ${sql.literal("hello")}
+        `;
+        expect(statement.text).toEqual(unindent `
+            SELECT * FROM posts WHERE title = 'hello'
+        `);
+        expect(statement.values).toEqual([]);
+    });
+    test("interpolating a literal with quotes", () => {
+        const statement = sql `
+            SELECT ${sql.literal("O'Reilly")} FROM authors
+        `;
+        expect(statement.text).toEqual(unindent `
+            SELECT 'O''Reilly' FROM authors
+        `);
+        expect(statement.values).toEqual([]);
+    });
+});
+describe("sql.join", () => {
+    test("joining zero statements", () => {
+        const statement = sql.join([]);
+        expect(statement.text).toEqual("");
+        expect(statement.values).toEqual([]);
+    });
+    test("joining one statement", () => {
+        const statement = sql.join([sql `name = ${"axolotl"}`]);
+        expect(statement.text).toEqual("name = $1");
+        expect(statement.values).toEqual(["axolotl"]);
+    });
+    test("joining two statements", () => {
+        const statement = sql.join([sql `name = ${"axolotl"}`, sql `name = ${"binturong"}`], " OR ");
+        expect(statement.text).toEqual("name = $1 OR name = $2");
+        expect(statement.values).toEqual(["axolotl", "binturong"]);
+    });
+    test("joining identifiers", () => {
+        const statement = sql.join(["name", "age"].map(sql.ident), " AND ");
+        expect(statement.text).toEqual(`"name" AND "age"`);
+        expect(statement.values).toEqual([]);
+    });
+    test("passing a schema as an argument to the template tag", () => {
+        const statement = sql(z.object({ title: z.string() })) `SELECT ${sql.ident("title")} FROM ${sql.ident("posts")}`;
+        expect(statement.schema).toBeInstanceOf(z.ZodObject);
+        expect(statement.text).toEqual(unindent `
+            SELECT "title" FROM "posts"
+        `);
+    });
+    test("append allows appending another SQL fragment using the tagged template literal style", () => {
+        const statement = sql `
+            SELECT title FROM posts
+            WHERE likes > ${10}
+        `;
+        statement.append `AND author = ${"Stewart Home"}`;
+        expect(statement.pretty).toEqual(unindent `
+            SELECT
+                title
+            FROM
+                posts
+            WHERE
+                likes > $1
+                AND author = $2
+        `);
+        expect(statement.values).toEqual([10, "Stewart Home"]);
+    });
+    test("appending to an empty SQLStatement", () => {
+        const statement = new SQLStatement();
+        statement.append `SELECT title FROM posts`;
+        expect(statement.pretty).toEqual(unindent `
+            SELECT
+                title
+            FROM
+                posts
+        `);
+    });
+});

package/package.json

@@ -0,0 +1,53 @@
+{
+  "name": "@casekit/sql",
+  "description": "",
+  "version": "0.0.0-20250322230249",
+  "author": "",
+  "dependencies": {
+    "@casekit/unindent": "^1.0.5",
+    "es-toolkit": "^1.33.0",
+    "sql-formatter": "^15.5.1",
+    "@casekit/toolbox": "0.0.0-20250322230249"
+  },
+  "devDependencies": {
+    "@trivago/prettier-plugin-sort-imports": "^5.2.2",
+    "@types/node": "^22.13.11",
+    "@types/pg": "^8.11.11",
+    "@vitest/coverage-v8": "^3.0.9",
+    "dotenv": "^16.4.7",
+    "prettier": "^3.5.3",
+    "prettier-plugin-svelte": "^3.3.3",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.9",
+    "@casekit/tsconfig": "0.0.0-20250322230249",
+    "@casekit/prettier-config": "0.0.0-20250322230249"
+  },
+  "exports": {
+    ".": "./build/index.js"
+  },
+  "files": [
+    "/build"
+  ],
+  "imports": {
+    "#*": "./build/*"
+  },
+  "keywords": [],
+  "license": "ISC",
+  "main": "index.js",
+  "peerDependencies": {
+    "pg": "^8.13.1",
+    "zod": "^3.24.2"
+  },
+  "prettier": "@casekit/prettier-config",
+  "type": "module",
+  "scripts": {
+    "build": "rm -rf ./build && tsc",
+    "build:watch": "tsc --watch",
+    "format:check": "prettier --check .",
+    "format": "prettier --write .",
+    "lint": "eslint src --max-warnings 0",
+    "test": "vitest --run --typecheck --coverage",
+    "test:watch": "vitest",
+    "typecheck": "tsc --noEmit"
+  }
+}