svelte-reflector 2.0.0 → 2.1.2

package/README.md

@@ -265,6 +265,28 @@ The auto-injected `setQueryGroup([...])` constructor on the generated
 `setQueryGroup` manually from `$reflector/reflector.svelte` if you still
 need batch URL writes.
 
+#### Ephemeral pagination (sidebar / widget)
+
+Sometimes a list lives outside the canonical route — a global sidebar, a
+widget, a paginated combobox in a modal — and should NOT mutate the
+current URL. For those cases, every generated `call()` with query params
+accepts an optional `queryOverride`:
+
+```typescript
+const sidebar = new UserService();
+
+// Current URL stays put. Request goes out with ?page=2&limit=10.
+await sidebar.listAll({
+  queryOverride: { page: "2", limit: "10" },
+});
+```
+
+When `queryOverride` is passed, the method skips `this.querys.bundle()`
+entirely and uses the override as `queryData`. Without it, the method
+reads from `QueryBuilder.value` (the URL) as usual — so you can mix and
+match on a per-call basis. Omit a key to drop it from the request; pass
+`null` to send a literal `null`.
+
 ## Configuration
 
 ### Environment Variables

package/dist/core/generators/ApiCallStrategy.js

@@ -1,3 +1,4 @@
+import { queryOverrideTypeLiteral } from "./queryOverride.js";
 export class ApiCallStrategy {
     listStateAccess(_method) {
         return "this.data";
@@ -15,6 +16,11 @@ export class ApiCallStrategy {
     buildParamsType(method) {
         const responseType = method.responseTypeInterface;
         const pathsBlock = this.buildPathsInfo(method);
+        const queryBlock = queryOverrideTypeLiteral(method.analyzers.props.querys);
+        if (queryBlock) {
+            const pathsArg = pathsBlock ?? "void";
+            return `ApiCallParams<${responseType}, ${pathsArg}, ${queryBlock}>`;
+        }
         if (pathsBlock) {
             return `ApiCallParams<${responseType}, ${pathsBlock}>`;
         }

package/dist/core/generators/CallMethodGenerator.js

@@ -8,43 +8,43 @@ export class CallMethodGenerator {
         const { inside, outside } = this.buildApiCall(method, strategy);
         const methodReturn = this.buildMethodReturn(method, strategy);
         const signature = strategy.buildSignature(method);
-        return `
-      ${description}
-      ${signature} {
-
-        const behavior = params?.behavior ?? new Behavior();
-        const { onError, onSuccess } = behavior;
-
-        this.loading = true;
-        ${props}
-        const endpoint = ${endpoint}
-
-        ${outside}
-
-        try {
-          ${inside}
-          await onSuccess?.(response);
-
-          return ${methodReturn};
-        } catch (e) {
-          let parsedError: ApiErrorResponse;
-          try {
-            parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
-          } catch {
-            parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
-          }
-          return await onError?.(parsedError);
-        } finally {
-          this.loading = false;
-        }
-      }
+        return `
+      ${description}
+      ${signature} {
+
+        const behavior = params?.behavior ?? new Behavior();
+        const { onError, onSuccess } = behavior;
+
+        this.loading = true;
+        ${props}
+        const endpoint = ${endpoint}
+
+        ${outside}
+
+        try {
+          ${inside}
+          await onSuccess?.(response);
+
+          return ${methodReturn};
+        } catch (e) {
+          let parsedError: ApiErrorResponse;
+          try {
+            parsedError = JSON.parse((e as Error).message) as ApiErrorResponse;
+          } catch {
+            parsedError = { error: 'unknown', message: (e as Error).message ?? String(e) };
+          }
+          return await onError?.(parsedError);
+        } finally {
+          this.loading = false;
+        }
+      }
     `;
     }
     buildProps(method) {
         const { querys, paths, cookies } = method.analyzers.props;
         const lines = [];
         if (querys.length > 0) {
-            lines.push(`const { ${this.joinNames(querys)} } = this.querys.bundle()`);
+            lines.push(`const { ${this.joinNames(querys)} } = params?.queryOverride ?? this.querys.bundle()`);
         }
         if (paths.length > 0) {
             lines.push(`const { ${this.joinNames(paths)} } = params?.paths ?? this.paths`);
@@ -73,13 +73,13 @@ export class CallMethodGenerator {
     }
     buildListCall(method, responseType, strategy) {
         const querys = this.joinNames(method.analyzers.props.querys);
-        const inside = `
-      const response = await api.get<${responseType}, unknown>({
-        endpoint,
-        queryData: { ${querys} }
-      })
-      ${strategy.listStateAccess(method)} = ${method.analyzers.request.responseType}.from(response.data);
-      this.totalPages = response.totalPages;
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        queryData: { ${querys} }
+      })
+      ${strategy.listStateAccess(method)} = ${method.analyzers.request.responseType}.from(response.data);
+      this.totalPages = response.totalPages;
     `;
         return { inside, outside: "" };
     }
@@ -90,13 +90,13 @@ export class CallMethodGenerator {
         const assignment = rType && !isPrimitive
             ? `${strategy.entityStateAccess(method)} = new ${rType}({ data: response })`
             : "";
-        const inside = `
-      const response = await api.get<${responseType}, unknown>({
-        endpoint,
-        ${querys}
-      })
-
-      ${assignment}
+        const inside = `
+      const response = await api.get<${responseType}, unknown>({
+        endpoint,
+        ${querys}
+      })
+
+      ${assignment}
     `;
         return { inside, outside: "" };
     }
@@ -111,23 +111,23 @@ export class CallMethodGenerator {
         if (hasHeaders) {
             outside.push(`const headers = this.headers.bundle()`);
         }
-        const inside = `
-      const response = await api.${apiType}<${responseType}>({
-        endpoint,
-        ${hasData ? "data," : ""}
-        ${hasHeaders ? "headers," : ""}
-      })
+        const inside = `
+      const response = await api.${apiType}<${responseType}>({
+        endpoint,
+        ${hasData ? "data," : ""}
+        ${hasHeaders ? "headers," : ""}
+      })
     `;
         return { inside, outside: outside.join("\n") };
     }
     buildDeleteCall(method, responseType, bodyType, strategy) {
         const hasData = !!bodyType;
         const outside = hasData ? `const data = ${strategy.formStateAccess(method)}.bundle()` : "";
-        const inside = `
-      const response = await api.delete<${responseType}, unknown>({
-        endpoint,
-        ${hasData ? "data," : ""}
-      })
+        const inside = `
+      const response = await api.delete<${responseType}, unknown>({
+        endpoint,
+        ${hasData ? "data," : ""}
+      })
     `;
         return { inside, outside };
     }

package/dist/core/generators/ModuleCallStrategy.d.ts

@@ -6,4 +6,5 @@ export declare class ModuleCallStrategy implements CallStrategy {
     formStateAccess(method: CallMethodInput): string;
     private buildParamsType;
     private buildPathsBlock;
+    private buildQueryOverrideBlock;
 }

package/dist/core/generators/ModuleCallStrategy.js

@@ -1,4 +1,5 @@
 import { treatByUppercase } from "../../helpers/helpers.js";
+import { queryOverrideEntryType } from "./queryOverride.js";
 export class ModuleCallStrategy {
     listStateAccess(method) {
         return `this.list${method.stateSuffix}`;
@@ -17,27 +18,36 @@ export class ModuleCallStrategy {
     buildParamsType(method) {
         const behaviorType = `Behavior<${method.responseTypeInterface}, ApiErrorResponse>`;
         const pathsBlock = this.buildPathsBlock(method);
-        if (pathsBlock) {
-            return `{
-        behavior?: ${behaviorType};${pathsBlock}
-      }`;
-        }
-        return `{
-      behavior?: ${behaviorType};
+        const queryBlock = this.buildQueryOverrideBlock(method);
+        const blocks = [`behavior?: ${behaviorType};`, pathsBlock, queryBlock]
+            .filter((b) => !!b)
+            .join("\n");
+        return `{
+      ${blocks}
     }`;
     }
     buildPathsBlock(method) {
         const paths = method.analyzers.props.paths;
         if (paths.length === 0)
             return undefined;
-        return `
-    paths?: {
+        return `paths?: {
       ${paths
             .map((p) => {
             const type = p.rawType ?? p.type;
             return `${p.name}: ${type}`;
         })
-            .join("\n")}
-    }`;
+            .join("\n")}
+    };`;
+    }
+    buildQueryOverrideBlock(method) {
+        const querys = method.analyzers.props.querys;
+        if (querys.length === 0)
+            return undefined;
+        const fields = querys
+            .map((q) => `${q.name}?: ${queryOverrideEntryType(q)}`)
+            .join("\n");
+        return `queryOverride?: {
+      ${fields}
+    };`;
     }
 }

package/dist/core/generators/queryOverride.d.ts

@@ -0,0 +1,12 @@
+import type { AttributeProp } from "../../types/types.js";
+/** TS type literal for a single query override entry. Mirrors the
+ *  shape produced by each Prop's bundle entry:
+ *    PrimitiveProp / EnumProp     → `string | null`
+ *    ArrayProp (enum)             → `${type}[]`
+ *    ArrayProp (non-enum, raro)   → `string[]`
+ */
+export declare function queryOverrideEntryType(q: AttributeProp): string;
+/** Inline TS object type literal for the full queryOverride bag,
+ *  derived from the method's query props. Returns undefined when there
+ *  are no query params (caller should skip emitting the slot). */
+export declare function queryOverrideTypeLiteral(querys: AttributeProp[]): string | undefined;

package/dist/core/generators/queryOverride.js

@@ -0,0 +1,22 @@
+/** TS type literal for a single query override entry. Mirrors the
+ *  shape produced by each Prop's bundle entry:
+ *    PrimitiveProp / EnumProp     → `string | null`
+ *    ArrayProp (enum)             → `${type}[]`
+ *    ArrayProp (non-enum, raro)   → `string[]`
+ */
+export function queryOverrideEntryType(q) {
+    if ("isEnum" in q && q.isEnum)
+        return `${q.type}[]`;
+    if (!("rawType" in q) && !("enumName" in q))
+        return "string[]";
+    return "string | null";
+}
+/** Inline TS object type literal for the full queryOverride bag,
+ *  derived from the method's query props. Returns undefined when there
+ *  are no query params (caller should skip emitting the slot). */
+export function queryOverrideTypeLiteral(querys) {
+    if (querys.length === 0)
+        return undefined;
+    const fields = querys.map((q) => `${q.name}?: ${queryOverrideEntryType(q)}`).join("; ");
+    return `{ ${fields} }`;
+}

package/dist/runtime/reflector.svelte.ts

@@ -9,9 +9,10 @@ type ValidatorResult = string | null;
 type ValidatorFn<T> = (v: T) => ValidatorResult;
 type BundleResult<T> = T extends { bundle: () => infer R } ? R : T;
 
-export type ApiCallParams<TResponse, TPaths = void> = TPaths extends void
-  ? { behavior?: Behavior<TResponse, ApiErrorResponse> }
-  : { behavior?: Behavior<TResponse, ApiErrorResponse>; paths?: TPaths };
+export type ApiCallParams<TResponse, TPaths = void, TQuery = void> = {
+  behavior?: Behavior<TResponse, ApiErrorResponse>;
+} & (TPaths extends void ? object : { paths?: TPaths }) &
+  (TQuery extends void ? object : { queryOverride?: TQuery });
 
 type PartialBuildedInput<T> = {
   [K in Exclude<keyof T, "bundle">]?: BuildedInput<T[K]>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-reflector",
-  "version": "2.0.0",
+  "version": "2.1.2",
   "description": "Reflects zod types from openAPI schemas",
   "type": "module",
   "main": "./dist/index.js",