ty-fetch 0.1.2 → 0.2.0

package/dist/core/ast-helpers.js

@@ -36,6 +36,10 @@ function findFetchCalls(ts, sourceFile) {
                 const urlStart = nodeStart(arg) + 1; // skip opening quote
                 const urlLength = nodeLen(arg) - 2; // exclude quotes
                 let jsonBody = null;
+                let queryParams = null;
+                let pathParams = null;
+                let queryObjRange = null;
+                let pathObjRange = null;
                 if (node.arguments.length >= 2) {
                     const optionsArg = node.arguments[1];
                     if (ts.isObjectLiteralExpression(optionsArg)) {
@@ -43,6 +47,22 @@ function findFetchCalls(ts, sourceFile) {
                         if (jsonProp && ts.isObjectLiteralExpression(jsonProp.initializer)) {
                             jsonBody = extractJsonProperties(ts, sourceFile, jsonProp.initializer);
                         }
+                        // Extract params.query and params.path
+                        const paramsProp = optionsArg.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "params");
+                        if (paramsProp && ts.isObjectLiteralExpression(paramsProp.initializer)) {
+                            for (const sub of paramsProp.initializer.properties) {
+                                if (!ts.isPropertyAssignment(sub) || !ts.isIdentifier(sub.name))
+                                    continue;
+                                if (sub.name.text === "query" && ts.isObjectLiteralExpression(sub.initializer)) {
+                                    queryParams = extractParamNames(ts, sourceFile, sub.initializer);
+                                    queryObjRange = { start: nodeStart(sub.initializer), end: sub.initializer.getEnd() };
+                                }
+                                else if (sub.name.text === "path" && ts.isObjectLiteralExpression(sub.initializer)) {
+                                    pathParams = extractParamNames(ts, sourceFile, sub.initializer);
+                                    pathObjRange = { start: nodeStart(sub.initializer), end: sub.initializer.getEnd() };
+                                }
+                            }
+                        }
                     }
                 }
                 results.push({
@@ -53,6 +73,10 @@ function findFetchCalls(ts, sourceFile) {
                     callStart: nodeStart(node),
                     callLength: nodeLen(node),
                     jsonBody,
+                    queryParams,
+                    pathParams,
+                    queryObjRange,
+                    pathObjRange,
                 });
             }
         }
@@ -111,3 +135,21 @@ function extractJsonProperties(ts, sf, obj) {
     }
     return props;
 }
+function extractParamNames(ts, sf, obj) {
+    function nodeStart(n) {
+        return n.getStart(sf);
+    }
+    function nodeLen(n) {
+        return n.getEnd() - nodeStart(n);
+    }
+    const params = [];
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = ts.isIdentifier(prop.name) ? prop.name.text : ts.isStringLiteral(prop.name) ? prop.name.text : null;
+        if (!name)
+            continue;
+        params.push({ name, nameStart: nodeStart(prop.name), nameLength: nodeLen(prop.name) });
+    }
+    return params;
+}

package/dist/core/schema-utils.d.ts

@@ -7,3 +7,8 @@ export declare function getRequestBodySchema(operation: any): any | null;
 export declare function getResponseSchema(operation: any): any | null;
 /** Return true if the operation's request body is marked as required. */
 export declare function isRequestBodyRequired(operation: any): boolean;
+/** Extract parameter definitions from an operation and its parent path item. */
+export declare function getOperationParams(operation: any, pathItem: any, spec: OpenAPISpec, filterIn: "query" | "path"): Array<{
+    name: string;
+    required: boolean;
+}>;

package/dist/core/schema-utils.js

@@ -4,6 +4,7 @@ exports.resolveSchemaRef = resolveSchemaRef;
 exports.getRequestBodySchema = getRequestBodySchema;
 exports.getResponseSchema = getResponseSchema;
 exports.isRequestBodyRequired = isRequestBodyRequired;
+exports.getOperationParams = getOperationParams;
 /** Resolve a $ref pointer to its target schema, or return the schema as-is if not a ref. */
 function resolveSchemaRef(schema, spec) {
     if (!schema)
@@ -27,7 +28,29 @@ function getResponseSchema(operation) {
     const resp = operation?.responses?.["200"] ?? operation?.responses?.["201"];
     return resp?.content?.["application/json"]?.schema ?? null;
 }
+/** Resolve a $ref pointer to a parameter definition. */
+function resolveParamRef(ref, spec) {
+    const match = ref.match(/^#\/components\/parameters\/(.+)$/);
+    if (match)
+        return spec.components?.parameters?.[match[1]] ?? null;
+    // Also try schemas ref as fallback
+    return resolveSchemaRef({ $ref: ref }, spec);
+}
 /** Return true if the operation's request body is marked as required. */
 function isRequestBodyRequired(operation) {
     return !!operation?.requestBody?.required;
 }
+/** Extract parameter definitions from an operation and its parent path item. */
+function getOperationParams(operation, pathItem, spec, filterIn) {
+    const allParams = [...(operation?.parameters ?? []), ...(pathItem?.parameters ?? [])];
+    const result = [];
+    const seen = new Set();
+    for (const param of allParams) {
+        const resolved = param.$ref ? resolveParamRef(param.$ref, spec) ?? param : param;
+        if (resolved?.in === filterIn && resolved?.name && !seen.has(resolved.name)) {
+            seen.add(resolved.name);
+            result.push({ name: resolved.name, required: !!resolved.required });
+        }
+    }
+    return result;
+}

package/dist/core/types.d.ts

@@ -35,6 +35,25 @@ export interface FetchCallInfo {
     callLength: number;
     /** JSON body properties if present: [{ name, nameStart, nameLength, valueStart, valueLength, valueText, valueKind }] */
     jsonBody: JsonBodyProperty[] | null;
+    /** params.query properties */
+    queryParams: ParamProperty[] | null;
+    /** params.path properties */
+    pathParams: ParamProperty[] | null;
+    /** Position range of the query object literal (for completions) */
+    queryObjRange: {
+        start: number;
+        end: number;
+    } | null;
+    /** Position range of the path object literal (for completions) */
+    pathObjRange: {
+        start: number;
+        end: number;
+    } | null;
+}
+export interface ParamProperty {
+    name: string;
+    nameStart: number;
+    nameLength: number;
 }
 export interface JsonBodyProperty {
     name: string;

package/dist/generate-types.js

@@ -127,13 +127,7 @@ function generateDtsContent(domainSpecs) {
                         const paramSchema = resolved.schema?.$ref
                             ? (resolveRef(spec, resolved.schema.$ref) ?? resolved.schema)
                             : (resolved.schema ?? null);
-                        const tsType = paramSchema?.type === "integer"
-                            ? "number"
-                            : paramSchema?.type === "number"
-                                ? "number"
-                                : paramSchema?.type === "boolean"
-                                    ? "boolean"
-                                    : "string";
+                        const tsType = inferParamType(paramSchema);
                         queryParams.push({
                             name: resolved.name,
                             type: tsType,
@@ -203,6 +197,27 @@ function generateDtsContent(domainSpecs) {
     lines.push("}");
     return lines.join("\n");
 }
+/** Infer a TypeScript type string from an OpenAPI parameter schema, including enum unions and arrays. */
+function inferParamType(paramSchema) {
+    if (!paramSchema)
+        return "string";
+    // Enum → string literal union
+    if (paramSchema.enum && paramSchema.enum.length > 0) {
+        return paramSchema.enum
+            .map((v) => (typeof v === "string" ? `"${v}"` : String(v)))
+            .join(" | ");
+    }
+    // Array with items
+    if (paramSchema.type === "array" && paramSchema.items) {
+        const itemType = inferParamType(paramSchema.items);
+        return `(${itemType})[]`;
+    }
+    if (paramSchema.type === "integer" || paramSchema.type === "number")
+        return "number";
+    if (paramSchema.type === "boolean")
+        return "boolean";
+    return "string";
+}
 function resolveRef(spec, ref) {
     // Handle #/components/schemas/Foo
     const match = ref.match(/^#\/components\/schemas\/(.+)$/);

package/dist/plugin/index.js

@@ -123,35 +123,39 @@ function init(modules) {
                         source: "ty-fetch",
                     });
                 }
+                const specPath = (0, core_1.findSpecPath)(apiPath, entry.spec);
                 // Body validation
-                if (call.httpMethod && call.jsonBody) {
-                    const specPath = (0, core_1.findSpecPath)(apiPath, entry.spec);
-                    if (specPath) {
-                        const operation = entry.spec.paths[specPath]?.[call.httpMethod];
-                        const reqSchema = operation?.requestBody?.content?.["application/json"]?.schema ??
-                            operation?.requestBody?.content?.["application/x-www-form-urlencoded"]?.schema;
-                        if (reqSchema) {
-                            const resolved = (0, core_1.resolveSchemaRef)(reqSchema, entry.spec);
-                            if (resolved?.properties) {
-                                // Find jsonObj start from the call expression in the AST
-                                const callNode = sourceFile.statements.length > 0 ? findCallAtPosition(ts, sourceFile, call.callStart) : null;
-                                const jsonObjStart = callNode ? getJsonObjStart(ts, callNode) : call.callStart;
-                                const bodyDiags = (0, core_1.validateJsonBody)(call.jsonBody, resolved, entry.spec, jsonObjStart);
-                                for (const d of bodyDiags) {
-                                    extra.push({
-                                        file: sourceFile,
-                                        start: d.start,
-                                        length: d.length,
-                                        messageText: d.message,
-                                        category: ts.DiagnosticCategory.Error,
-                                        code: d.code,
-                                        source: "ty-fetch",
-                                    });
-                                }
+                if (call.httpMethod && call.jsonBody && specPath) {
+                    const operation = entry.spec.paths[specPath]?.[call.httpMethod];
+                    const reqSchema = operation?.requestBody?.content?.["application/json"]?.schema ??
+                        operation?.requestBody?.content?.["application/x-www-form-urlencoded"]?.schema;
+                    if (reqSchema) {
+                        const resolved = (0, core_1.resolveSchemaRef)(reqSchema, entry.spec);
+                        if (resolved?.properties) {
+                            const callNode = sourceFile.statements.length > 0 ? findCallAtPosition(ts, sourceFile, call.callStart) : null;
+                            const jsonObjStart = callNode ? getJsonObjStart(ts, callNode) : call.callStart;
+                            const bodyDiags = (0, core_1.validateJsonBody)(call.jsonBody, resolved, entry.spec, jsonObjStart);
+                            for (const d of bodyDiags) {
+                                extra.push({
+                                    file: sourceFile,
+                                    start: d.start,
+                                    length: d.length,
+                                    messageText: d.message,
+                                    category: ts.DiagnosticCategory.Error,
+                                    code: d.code,
+                                    source: "ty-fetch",
+                                });
                             }
                         }
                     }
                 }
+                // Params validation (query + path)
+                if (call.httpMethod && specPath) {
+                    const operation = entry.spec.paths[specPath]?.[call.httpMethod];
+                    const pathItem = entry.spec.paths[specPath];
+                    validateParams(call.queryParams, "query", operation, pathItem, entry.spec, sourceFile, extra);
+                    validateParams(call.pathParams, "path", operation, pathItem, entry.spec, sourceFile, extra);
+                }
             }
             // Regenerate types when URLs change
             const currentUrls = calls
@@ -181,38 +185,76 @@ function init(modules) {
                 return prior;
             const calls = (0, core_1.findFetchCalls)(ts, sourceFile);
             for (const call of calls) {
-                if (position < call.urlStart || position > call.urlStart + call.urlLength)
-                    continue;
-                const parsed = (0, core_1.parseFetchUrl)(call.url);
-                if (!parsed)
-                    continue;
-                const entry = (0, core_1.ensureSpec)(parsed.domain, logger, onSpecLoaded);
-                if (entry.status !== "loaded" || !entry.spec)
-                    continue;
-                const basePath = (0, core_1.getBasePath)(entry.spec);
-                const urlPrefix = `https://${parsed.domain}${basePath}`;
-                const pathEntries = [];
-                for (const [specPath, methods] of Object.entries(entry.spec.paths)) {
-                    const available = Object.keys(methods).filter((m) => !["parameters", "summary", "description"].includes(m));
-                    if (call.httpMethod && !available.includes(call.httpMethod))
+                // URL completions
+                if (position >= call.urlStart && position <= call.urlStart + call.urlLength) {
+                    const parsed = (0, core_1.parseFetchUrl)(call.url);
+                    if (!parsed)
                         continue;
-                    const fullUrl = `${urlPrefix}${specPath}`;
-                    pathEntries.push({
-                        name: fullUrl,
-                        kind: ts.ScriptElementKind.string,
-                        sortText: `0${specPath}`,
-                        replacementSpan: { start: call.urlStart, length: call.urlLength },
-                        insertText: fullUrl,
-                        labelDetails: { description: available.map((m) => m.toUpperCase()).join(", ") },
-                    });
+                    const entry = (0, core_1.ensureSpec)(parsed.domain, logger, onSpecLoaded);
+                    if (entry.status !== "loaded" || !entry.spec)
+                        continue;
+                    const basePath = (0, core_1.getBasePath)(entry.spec);
+                    const urlPrefix = `https://${parsed.domain}${basePath}`;
+                    const pathEntries = [];
+                    for (const [specPath, methods] of Object.entries(entry.spec.paths)) {
+                        const available = Object.keys(methods).filter((m) => !["parameters", "summary", "description"].includes(m));
+                        if (call.httpMethod && !available.includes(call.httpMethod))
+                            continue;
+                        const fullUrl = `${urlPrefix}${specPath}`;
+                        pathEntries.push({
+                            name: fullUrl,
+                            kind: ts.ScriptElementKind.string,
+                            sortText: `0${specPath}`,
+                            replacementSpan: { start: call.urlStart, length: call.urlLength },
+                            insertText: fullUrl,
+                            labelDetails: { description: available.map((m) => m.toUpperCase()).join(", ") },
+                        });
+                    }
+                    const filtered = pathEntries.filter((e) => e.name.startsWith(call.url) || call.url.endsWith("/"));
+                    return {
+                        isGlobalCompletion: false,
+                        isMemberCompletion: false,
+                        isNewIdentifierLocation: false,
+                        entries: filtered.length > 0 ? filtered : pathEntries,
+                    };
+                }
+                // Param completions (query / path)
+                const inQuery = call.queryObjRange && position > call.queryObjRange.start && position < call.queryObjRange.end;
+                const inPath = call.pathObjRange && position > call.pathObjRange.start && position < call.pathObjRange.end;
+                if ((inQuery || inPath) && call.httpMethod) {
+                    const parsed = (0, core_1.parseFetchUrl)(call.url);
+                    if (!parsed)
+                        continue;
+                    const entry = (0, core_1.ensureSpec)(parsed.domain, logger, onSpecLoaded);
+                    if (entry.status !== "loaded" || !entry.spec)
+                        continue;
+                    const apiPath = (0, core_1.stripBasePath)(parsed.path, entry.spec);
+                    const specPath = (0, core_1.findSpecPath)(apiPath, entry.spec);
+                    if (!specPath)
+                        continue;
+                    const operation = entry.spec.paths[specPath]?.[call.httpMethod];
+                    const pathItem = entry.spec.paths[specPath];
+                    const filterIn = inQuery ? "query" : "path";
+                    const specParams = (0, core_1.getOperationParams)(operation, pathItem, entry.spec, filterIn);
+                    const existing = (inQuery ? call.queryParams : call.pathParams) ?? [];
+                    const existingNames = new Set(existing.map((p) => p.name));
+                    const entries = specParams
+                        .filter((p) => !existingNames.has(p.name))
+                        .map((p) => ({
+                        name: p.name,
+                        kind: ts.ScriptElementKind.memberVariableElement,
+                        sortText: p.required ? `0${p.name}` : `1${p.name}`,
+                        labelDetails: { description: p.required ? "(required)" : "(optional)" },
+                    }));
+                    if (entries.length > 0) {
+                        return {
+                            isGlobalCompletion: false,
+                            isMemberCompletion: true,
+                            isNewIdentifierLocation: false,
+                            entries: [...entries, ...(prior?.entries ?? [])],
+                        };
+                    }
                 }
-                const filtered = pathEntries.filter((e) => e.name.startsWith(call.url) || call.url.endsWith("/"));
-                return {
-                    isGlobalCompletion: false,
-                    isMemberCompletion: false,
-                    isNewIdentifierLocation: false,
-                    entries: filtered.length > 0 ? filtered : pathEntries,
-                };
             }
             return prior;
         };
@@ -270,6 +312,27 @@ function init(modules) {
     }
     return { create };
 }
+function validateParams(params, filterIn, operation, pathItem, spec, sourceFile, extra) {
+    if (!params || params.length === 0)
+        return;
+    const ts = require("typescript");
+    const specParams = (0, core_1.getOperationParams)(operation, pathItem, spec, filterIn);
+    const validNames = new Set(specParams.map((p) => p.name));
+    for (const param of params) {
+        if (!validNames.has(param.name)) {
+            const suggestions = specParams.map((p) => `'${p.name}'`).join(", ");
+            extra.push({
+                file: sourceFile,
+                start: param.nameStart,
+                length: param.nameLength,
+                messageText: `Unknown ${filterIn} parameter '${param.name}'.${suggestions ? ` Available: ${suggestions}` : ""}`,
+                category: ts.DiagnosticCategory.Error,
+                code: 99005,
+                source: "ty-fetch",
+            });
+        }
+    }
+}
 // Helper to find a CallExpression at a position in the AST
 function findCallAtPosition(ts, sourceFile, pos) {
     let found = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ty-fetch",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Automatic TypeScript types for any REST API. No codegen, no manual types — just fetch.",
   "license": "MIT",
   "keywords": [