@onreza/sqlx-js 0.4.0 → 0.5.0

package/dist/src/scan/scanner.d.ts

@@ -1,3 +1,4 @@
+import type { ScanConfig } from "../config.js";
 export type QueryCallSite = {
     file: string;
     line: number;
@@ -7,6 +8,12 @@ export type QueryCallSite = {
     kind: "inline" | "file";
     sqlFilePath?: string;
 };
-export declare function findSourceFiles(root: string): string[];
+export declare class ScanError extends Error {
+    readonly file: string;
+    readonly line: number;
+    readonly column: number;
+    constructor(file: string, line: number, column: number, message: string);
+}
+export declare function findSourceFiles(root: string, scan?: ScanConfig): string[];
 export declare function scanFile(absPath: string, root: string): QueryCallSite[];
-export declare function scanProject(root: string): QueryCallSite[];
+export declare function scanProject(root: string, scan?: ScanConfig): QueryCallSite[];

package/dist/src/scan/scanner.js

@@ -1,25 +1,67 @@
 import ts from "typescript";
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { dirname, join, relative, resolve } from "node:path";
-const EXCLUDE_DIRS = new Set(["node_modules", ".git", ".sqlx-js", "dist", "build", ".next"]);
+import { existsSync, readFileSync } from "node:fs";
+import { isAbsolute, join, relative, resolve } from "node:path";
+export class ScanError extends Error {
+    file;
+    line;
+    column;
+    constructor(file, line, column, message) {
+        super(`sqlx-js: ${file}:${line}:${column} — ${message}`);
+        this.file = file;
+        this.line = line;
+        this.column = column;
+        this.name = "ScanError";
+    }
+}
+const DEFAULT_EXCLUDES = [
+    "**/node_modules/**",
+    "**/.git/**",
+    "**/.sqlx-js/**",
+    "**/dist/**",
+    "**/build/**",
+    "**/.next/**",
+];
 const SQLX_MODULES = new Set(["@onreza/sqlx-js"]);
 const EXT = /\.(ts|tsx|mts|cts)$/;
-function walk(dir, out) {
-    for (const name of readdirSync(dir)) {
-        if (EXCLUDE_DIRS.has(name))
-            continue;
-        const full = join(dir, name);
-        const st = statSync(full);
-        if (st.isDirectory())
-            walk(full, out);
-        else if (EXT.test(name))
-            out.push(full);
+const TS_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+function formatConfigError(error) {
+    return ts.flattenDiagnosticMessageText(error.messageText, "\n");
+}
+function collectTsconfigFiles(configPath, out, visited) {
+    const resolved = resolve(configPath);
+    if (visited.has(resolved))
+        return;
+    visited.add(resolved);
+    const read = ts.readConfigFile(resolved, ts.sys.readFile);
+    if (read.error)
+        throw new Error(`sqlx-js scan: ${resolved}: ${formatConfigError(read.error)}`);
+    const parsed = ts.parseJsonConfigFileContent(read.config, ts.sys, resolve(resolved, ".."), undefined, resolved);
+    if (parsed.errors.length > 0) {
+        throw new Error(`sqlx-js scan: ${resolved}: ${parsed.errors.map(formatConfigError).join("; ")}`);
+    }
+    for (const file of parsed.fileNames) {
+        if (EXT.test(file))
+            out.add(resolve(file));
+    }
+    for (const reference of parsed.projectReferences ?? []) {
+        collectTsconfigFiles(ts.resolveProjectReferencePath(reference), out, visited);
     }
 }
-export function findSourceFiles(root) {
-    const out = [];
-    walk(root, out);
-    return out;
+export function findSourceFiles(root, scan = {}) {
+    const excludes = [...DEFAULT_EXCLUDES, ...(scan.exclude ?? [])];
+    if (scan.include !== undefined) {
+        if (scan.include.length === 0)
+            return [];
+        return ts.sys.readDirectory(root, TS_EXTENSIONS, excludes, scan.include).map((file) => resolve(file)).sort();
+    }
+    const configPath = join(root, "tsconfig.json");
+    if (!ts.sys.fileExists(configPath)) {
+        return ts.sys.readDirectory(root, TS_EXTENSIONS, excludes, ["**/*"]).map((file) => resolve(file)).sort();
+    }
+    const configured = new Set();
+    collectTsconfigFiles(configPath, configured, new Set());
+    const allowed = new Set(ts.sys.readDirectory(root, TS_EXTENSIONS, excludes, ["**/*"]).map((file) => resolve(file)));
+    return [...configured].filter((file) => allowed.has(file)).sort();
 }
 function classifyCallee(callee, scope) {
     if (ts.isIdentifier(callee)) {
@@ -45,7 +87,7 @@ function classifyCallee(callee, scope) {
             return { kind: "transaction" };
         if (methodName === "file")
             return { kind: "file" };
-        if (methodName === "one" || methodName === "optional")
+        if (methodName === "one" || methodName === "optional" || methodName === "execute")
             return { kind: "inline" };
         return null;
     }
@@ -57,7 +99,7 @@ function classifyCallee(callee, scope) {
         if (ts.isIdentifier(mid.expression) && scope.namespaces.has(mid.expression.text)) {
             if (mid.name.text !== "sql")
                 return null;
-            if (methodName === "one" || methodName === "optional")
+            if (methodName === "one" || methodName === "optional" || methodName === "execute")
                 return { kind: "inline" };
             if (methodName === "file")
                 return { kind: "file" };
@@ -72,7 +114,7 @@ function classifyCallee(callee, scope) {
                 return null;
             if (mid.name.text !== "file")
                 return null;
-            if (methodName === "one" || methodName === "optional")
+            if (methodName === "one" || methodName === "optional" || methodName === "execute")
                 return { kind: "file" };
             return null;
         }
@@ -83,7 +125,7 @@ function classifyCallee(callee, scope) {
             scope.namespaces.has(mid.expression.expression.text) &&
             mid.expression.name.text === "sql" &&
             mid.name.text === "file" &&
-            (methodName === "one" || methodName === "optional")) {
+            (methodName === "one" || methodName === "optional" || methodName === "execute")) {
             return { kind: "file" };
         }
     }
@@ -130,7 +172,7 @@ export function scanFile(absPath, root) {
     const recordInline = (first, args) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = here(first);
-            throw new Error(`sqlx-js: ${fileRel}:${pos.line}:${pos.column} — sql() requires a string literal as first argument`);
+            throw new ScanError(fileRel, pos.line, pos.column, "sql() requires a string literal as first argument");
         }
         const pos = here(first);
         out.push({
@@ -146,13 +188,22 @@ export function scanFile(absPath, root) {
     const recordFile = (first, args, callee) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = first ? here(first) : here(callee);
-            throw new Error(`sqlx-js: ${fileRel}:${pos.line}:${pos.column} — sql.file() requires a string literal path`);
+            throw new ScanError(fileRel, pos.line, pos.column, "sql.file() requires a string literal path");
         }
         const sqlPath = first.text;
-        const abs = resolve(dirname(absPath), sqlPath);
+        if (isAbsolute(sqlPath)) {
+            const pos = here(first);
+            throw new ScanError(fileRel, pos.line, pos.column, `sql.file path must be relative to --root: ${sqlPath}`);
+        }
+        const abs = resolve(root, sqlPath);
+        const rel = relative(root, abs);
+        if (rel === ".." || rel.startsWith(`..${process.platform === "win32" ? "\\" : "/"}`) || isAbsolute(rel)) {
+            const pos = here(first);
+            throw new ScanError(fileRel, pos.line, pos.column, `sql.file path escapes --root: ${sqlPath}`);
+        }
         if (!existsSync(abs)) {
             const pos = here(first);
-            throw new Error(`sqlx-js: ${fileRel}:${pos.line}:${pos.column} — sql.file path not found: ${sqlPath}`);
+            throw new ScanError(fileRel, pos.line, pos.column, `sql.file path not found: ${sqlPath}`);
         }
         const query = readFileSync(abs, "utf8");
         const pos = here(first);
@@ -163,7 +214,7 @@ export function scanFile(absPath, root) {
             query,
             paramCount: args.length - 1,
             kind: "file",
-            sqlFilePath: relative(root, abs),
+            sqlFilePath: sqlPath,
         });
         return true;
     };
@@ -272,8 +323,8 @@ export function scanFile(absPath, root) {
     visit(source, { sqlAliases: importedAliases, namespaces: importedNamespaces });
     return out;
 }
-export function scanProject(root) {
-    const files = findSourceFiles(root);
+export function scanProject(root, scan = {}) {
+    const files = findSourceFiles(root, scan);
     const out = [];
     for (const f of files) {
         for (const site of scanFile(f, root))

package/dist/src/typed.d.ts

@@ -4,17 +4,27 @@ type ParamsOf<T> = T extends {
 type RowOf<T> = T extends {
     row: infer R;
 } ? R : never;
+type ExecuteResult = import("./runtime.js").ExecuteResult;
+type JsonInputValue = import("./runtime.js").JsonInputValue;
+type JsonParameter<T> = import("./runtime.js").JsonParameter<T>;
+type PgArrayParameter<T> = import("./runtime.js").PgArrayParameter<T>;
+type JsonFn = <T extends JsonInputValue>(value: T) => JsonParameter<T>;
+type ArrayFn = <T>(value: readonly (T | null)[]) => PgArrayParameter<T>;
 export type TypedFile<TFileQueries> = {
     <P extends keyof TFileQueries>(path: P, ...params: ParamsOf<TFileQueries[P]>): Promise<RowOf<TFileQueries[P]>[]>;
     one: <P extends keyof TFileQueries>(path: P, ...params: ParamsOf<TFileQueries[P]>) => Promise<RowOf<TFileQueries[P]>>;
     optional: <P extends keyof TFileQueries>(path: P, ...params: ParamsOf<TFileQueries[P]>) => Promise<RowOf<TFileQueries[P]> | null>;
+    execute: <P extends keyof TFileQueries>(path: P, ...params: ParamsOf<TFileQueries[P]>) => Promise<ExecuteResult>;
 };
 export type TypedSql<TQueries, TFileQueries> = {
     <Q extends keyof TQueries>(query: Q, ...params: ParamsOf<TQueries[Q]>): Promise<RowOf<TQueries[Q]>[]>;
     one: <Q extends keyof TQueries>(query: Q, ...params: ParamsOf<TQueries[Q]>) => Promise<RowOf<TQueries[Q]>>;
     optional: <Q extends keyof TQueries>(query: Q, ...params: ParamsOf<TQueries[Q]>) => Promise<RowOf<TQueries[Q]> | null>;
+    execute: <Q extends keyof TQueries>(query: Q, ...params: ParamsOf<TQueries[Q]>) => Promise<ExecuteResult>;
     file: TypedFile<TFileQueries>;
     id: (...parts: string[]) => string;
+    json: JsonFn;
+    array: ArrayFn;
 };
 export type Typed<TQueries, TFileQueries, TTransactionOptions> = TypedSql<TQueries, TFileQueries> & {
     transaction: {

package/package.json

@@ -1,11 +1,12 @@
 {
   "name": "@onreza/sqlx-js",
-  "version": "0.4.0",
+  "version": "0.5.0",
   "description": "Compile-time-checked raw SQL for TypeScript + PostgreSQL. Inspired by sqlx.",
   "license": "MIT",
   "type": "module",
   "engines": {
-    "node": ">=18"
+    "node": ">=24",
+    "bun": ">=1.3"
   },
   "sideEffects": false,
   "main": "./dist/src/index.js",
@@ -49,13 +50,13 @@
     "migrations"
   ],
   "scripts": {
-    "prepare": "(test -f dist/bin/sqlx-js.js || bun run build) && ([ ! -d .git ] || lefthook install >/dev/null 2>&1 || true)",
-    "test": "bun test tests",
+    "prepare": "node scripts/prepare-package.mjs",
+    "test": "bun test tests --timeout 120000",
     "test:typecheck": "tsc --noEmit",
     "test:example": "bunx tsc -p example --noEmit",
     "sqlx:prepare": "bun bin/sqlx-js.ts prepare",
     "sqlx:migrate": "bun bin/sqlx-js.ts migrate",
-    "build": "rm -rf dist && tsc -p tsconfig.build.json && bun scripts/fix-dist-imports.ts",
+    "build": "node -e \"require('node:fs').rmSync('dist', { recursive: true, force: true })\" && tsc -p tsconfig.build.json && bun scripts/fix-dist-imports.ts",
     "prepack": "bun run build"
   },
   "peerDependencies": {