@onreza/sqlx-js 0.8.0 → 0.9.0

package/dist/src/scan/scanner.js

@@ -68,7 +68,7 @@ function classifyCallee(callee, scope) {
     if (ts.isIdentifier(callee)) {
         if (!scope.sqlAliases.has(callee.text))
             return null;
-        return { kind: "inline" };
+        return { kind: "inline", cardinality: "many" };
     }
     if (!ts.isPropertyAccessExpression(callee))
         return null;
@@ -79,7 +79,7 @@ function classifyCallee(callee, scope) {
         const id = callee.expression.text;
         if (scope.namespaces.has(id) || scope.clients.has(id)) {
             if (methodName === "sql")
-                return { kind: "inline" };
+                return { kind: "inline", cardinality: "many" };
             return null;
         }
         if (!scope.sqlAliases.has(id))
@@ -87,9 +87,10 @@ function classifyCallee(callee, scope) {
         if (methodName === "transaction")
             return { kind: "transaction" };
         if (methodName === "file")
-            return { kind: "file" };
-        if (methodName === "one" || methodName === "optional" || methodName === "execute")
-            return { kind: "inline" };
+            return { kind: "file", cardinality: "many" };
+        if (methodName === "one" || methodName === "optional" || methodName === "execute") {
+            return { kind: "inline", cardinality: methodName };
+        }
         return null;
     }
     if (ts.isPropertyAccessExpression(callee.expression)) {
@@ -101,10 +102,11 @@ function classifyCallee(callee, scope) {
             (scope.namespaces.has(mid.expression.text) || scope.clients.has(mid.expression.text))) {
             if (mid.name.text !== "sql")
                 return null;
-            if (methodName === "one" || methodName === "optional" || methodName === "execute")
-                return { kind: "inline" };
+            if (methodName === "one" || methodName === "optional" || methodName === "execute") {
+                return { kind: "inline", cardinality: methodName };
+            }
             if (methodName === "file")
-                return { kind: "file" };
+                return { kind: "file", cardinality: "many" };
             if (methodName === "transaction")
                 return { kind: "transaction" };
             return null;
@@ -116,8 +118,9 @@ function classifyCallee(callee, scope) {
                 return null;
             if (mid.name.text !== "file")
                 return null;
-            if (methodName === "one" || methodName === "optional" || methodName === "execute")
-                return { kind: "file" };
+            if (methodName === "one" || methodName === "optional" || methodName === "execute") {
+                return { kind: "file", cardinality: methodName };
+            }
             return null;
         }
         // ns.sql.file.X(...) and client.sql.file.X(...) chains
@@ -128,11 +131,32 @@ function classifyCallee(callee, scope) {
             mid.expression.name.text === "sql" &&
             mid.name.text === "file" &&
             (methodName === "one" || methodName === "optional" || methodName === "execute")) {
-            return { kind: "file" };
+            return { kind: "file", cardinality: methodName };
         }
     }
     return null;
 }
+function classifyDefinitionCallee(callee, scope) {
+    if (ts.isIdentifier(callee))
+        return scope.queryFactories.has(callee.text) ? "many" : null;
+    if (!ts.isPropertyAccessExpression(callee) || !ts.isIdentifier(callee.name))
+        return null;
+    const method = callee.name.text;
+    if (ts.isIdentifier(callee.expression) && scope.queryFactories.has(callee.expression.text)) {
+        return method === "one" || method === "optional" || method === "execute" ? method : null;
+    }
+    if (method === "defineQuery" &&
+        ts.isIdentifier(callee.expression) &&
+        scope.namespaces.has(callee.expression.text))
+        return "many";
+    if ((method === "one" || method === "optional" || method === "execute") &&
+        ts.isPropertyAccessExpression(callee.expression) &&
+        ts.isIdentifier(callee.expression.expression) &&
+        scope.namespaces.has(callee.expression.expression.text) &&
+        callee.expression.name.text === "defineQuery")
+        return method;
+    return null;
+}
 export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     const text = readFileSync(absPath, "utf8");
     const source = ts.createSourceFile(absPath, text, ts.ScriptTarget.ESNext, false, scriptKind(absPath));
@@ -147,6 +171,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     const importedAliases = new Set();
     const importedNamespaces = new Set();
     const importedClientFactories = new Set();
+    const importedQueryFactories = new Set();
     for (const stmt of source.statements) {
         if (!ts.isImportDeclaration(stmt))
             continue;
@@ -171,10 +196,15 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                     importedAliases.add(elem.name.text);
                 if (orig === "createSqlClient")
                     importedClientFactories.add(elem.name.text);
+                if (orig === "defineQuery")
+                    importedQueryFactories.add(elem.name.text);
             }
         }
     }
-    if (importedAliases.size === 0 && importedNamespaces.size === 0 && importedClientFactories.size === 0)
+    if (importedAliases.size === 0 &&
+        importedNamespaces.size === 0 &&
+        importedClientFactories.size === 0 &&
+        importedQueryFactories.size === 0)
         return [];
     const out = [];
     const here = (node) => {
@@ -182,7 +212,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         return { line: line + 1, column: character + 1 };
     };
     const fileRel = relative(root, absPath).replace(/\\/g, "/");
-    const recordInline = (first, args) => {
+    const recordInline = (first, args, cardinality) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = here(first);
             throw new ScanError(fileRel, pos.line, pos.column, "sql() requires a string literal as first argument");
@@ -205,10 +235,46 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             query: first.text,
             paramCount: args.length - 1,
             kind: "inline",
+            cardinality,
         });
         return true;
     };
-    const recordFile = (first, args, callee) => {
+    const recordDefinition = (args, callee, cardinality) => {
+        if (args.length < 1 || args.length > 2) {
+            const pos = here(callee);
+            throw new ScanError(fileRel, pos.line, pos.column, "defineQuery() requires a SQL literal and optional name");
+        }
+        const queryNode = args.length === 2 ? args[1] : args[0];
+        const nameNode = args.length === 2 ? args[0] : undefined;
+        if (!ts.isStringLiteralLike(queryNode) || (nameNode && !ts.isStringLiteralLike(nameNode))) {
+            const pos = here(queryNode);
+            throw new ScanError(fileRel, pos.line, pos.column, "defineQuery() requires string literals for its name and SQL");
+        }
+        if (nameNode && nameNode.text.trim() === "") {
+            const pos = here(nameNode);
+            throw new ScanError(fileRel, pos.line, pos.column, "defineQuery() name must not be empty");
+        }
+        const pos = here(queryNode);
+        let paramNames;
+        try {
+            paramNames = rewriteNamedParameters(queryNode.text).names;
+        }
+        catch (error) {
+            throw new ScanError(fileRel, pos.line, pos.column, error.message.replace(/^sqlx-js: /, ""));
+        }
+        out.push({
+            file: fileRel,
+            line: pos.line,
+            column: pos.column,
+            query: queryNode.text,
+            paramCount: paramNames.length,
+            kind: "inline",
+            cardinality,
+            ...(nameNode ? { queryName: nameNode.text } : {}),
+        });
+        return true;
+    };
+    const recordFile = (first, args, callee, cardinality) => {
         if (!ts.isStringLiteralLike(first)) {
             const pos = first ? here(first) : here(callee);
             throw new ScanError(fileRel, pos.line, pos.column, "sql.file() requires a string literal path");
@@ -247,6 +313,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             query,
             paramCount: args.length - 1,
             kind: "file",
+            cardinality,
             sqlFilePath: sqlPath,
         });
         return true;
@@ -267,6 +334,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         const nextSql = new Set(scope.sqlAliases);
         const nextNs = new Set(scope.namespaces);
         const nextFactories = new Set(scope.clientFactories);
+        const nextQueryFactories = new Set(scope.queryFactories);
         const nextClients = new Set(scope.clients);
         for (const binding of bindings) {
             for (const a of scope.sqlAliases) {
@@ -287,6 +355,12 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                     changed = true;
                 }
             }
+            for (const a of scope.queryFactories) {
+                if (bindingDeclares(binding, a)) {
+                    nextQueryFactories.delete(a);
+                    changed = true;
+                }
+            }
             for (const a of scope.clients) {
                 if (bindingDeclares(binding, a)) {
                     nextClients.delete(a);
@@ -295,7 +369,13 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
             }
         }
         return changed
-            ? { sqlAliases: nextSql, namespaces: nextNs, clientFactories: nextFactories, clients: nextClients }
+            ? {
+                sqlAliases: nextSql,
+                namespaces: nextNs,
+                clientFactories: nextFactories,
+                queryFactories: nextQueryFactories,
+                clients: nextClients,
+            }
             : scope;
     };
     const isClientFactoryCall = (initializer, scope) => {
@@ -322,6 +402,10 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
     };
     const visit = (node, scope) => {
         if (ts.isCallExpression(node)) {
+            const definitionCardinality = classifyDefinitionCallee(node.expression, scope);
+            if (definitionCardinality) {
+                recordDefinition(node.arguments, node.expression, definitionCardinality);
+            }
             const classified = classifyCallee(node.expression, scope);
             if (classified) {
                 if (classified.kind === "transaction") {
@@ -340,12 +424,12 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
                 else if (classified.kind === "file") {
                     const first = node.arguments[0];
                     if (first)
-                        recordFile(first, node.arguments, node.expression);
+                        recordFile(first, node.arguments, node.expression, classified.cardinality ?? "many");
                 }
                 else if (classified.kind === "inline") {
                     const first = node.arguments[0];
                     if (first)
-                        recordInline(first, node.arguments);
+                        recordInline(first, node.arguments, classified.cardinality ?? "many");
                 }
             }
         }
@@ -399,6 +483,7 @@ export function scanFile(absPath, root, modules = DEFAULT_SQLX_MODULES) {
         sqlAliases: importedAliases,
         namespaces: importedNamespaces,
         clientFactories: importedClientFactories,
+        queryFactories: importedQueryFactories,
         clients: new Set(),
     });
     return out;

package/dist/src/typed.d.ts

@@ -1,3 +1,4 @@
+import type { QUERY_EXECUTOR, QueryExecutorMethod } from "./query.js";
 type ParamsOf<T> = T extends {
     params: infer P;
 } ? P extends readonly unknown[] ? P : [P] : never[];
@@ -5,10 +6,10 @@ type RowOf<T> = T extends {
     row: infer R;
 } ? R : never;
 type ExecuteResult = import("./runtime.js").ExecuteResult;
-type JsonInputValue = import("./runtime.js").JsonInputValue;
+type JsonCompatible<T> = import("./runtime.js").JsonCompatible<T>;
 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 JsonFn = <T>(value: T & JsonCompatible<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]>[]>;
@@ -25,6 +26,7 @@ export type TypedSql<TQueries, TFileQueries> = {
     id: (...parts: string[]) => string;
     json: JsonFn;
     array: ArrayFn;
+    readonly [QUERY_EXECUTOR]?: QueryExecutorMethod;
 };
 export type Typed<TQueries, TFileQueries, TTransactionOptions> = TypedSql<TQueries, TFileQueries> & {
     transaction: {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@onreza/sqlx-js",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "Compile-time-checked raw SQL for TypeScript + PostgreSQL. Inspired by sqlx.",
   "license": "MIT",
   "type": "module",