flexible urls with implied params

.changeset/petite-deer-pay.md

@@ -0,0 +1,8 @@
+---
+"@getlang/parser": patch
+"@getlang/ast": patch
+"@getlang/get": patch
+"@getlang/lib": patch
+---
+
+flexible urls with implied params

packages/ast/src/ast.ts

@@ -48,7 +48,7 @@ type RequestStmt = {
 export type RequestExpr = {
   kind: 'RequestExpr'
   method: Token
-  url: Expr
+  url: TemplateExpr
   headers: RequestBlockExpr
   blocks: RequestBlockExpr[]
   body: Expr
@@ -214,7 +214,7 @@ const requestStmt = (request: RequestExpr): RequestStmt => ({
 
 const requestExpr = (
   method: Token,
-  url: Expr,
+  url: TemplateExpr,
   headers: RequestBlockExpr,
   blocks: RequestBlockExpr[],
   body: Expr,

packages/get/src/modules.ts

@@ -13,7 +13,6 @@ import { materialize } from './value.js'
 
 type Info = {
   ast: Program
-  inputs: Set<string>
   imports: Set<string>
   isMacro: boolean
 }
@@ -86,15 +85,20 @@ export class Modules {
     stack: string[],
     contextType?: TypeInfo,
   ): Promise<Entry> {
-    const { ast, inputs, imports } = await this.getInfo(module)
+    const { ast, imports } = await this.getInfo(module)
     const macros: string[] = []
     for (const i of imports) {
       const depInfo = await this.getInfo(i)
       if (depInfo.isMacro) {
         macros.push(i)
       }
     }
-    const { program: simplified, calls, modifiers } = desugar(ast, macros)
+    const {
+      program: simplified,
+      inputs,
+      calls,
+      modifiers,
+    } = desugar(ast, macros)
 
     const returnTypes: Record<string, TypeInfo> = {}
     for (const call of calls) {

packages/lib/src/net/http.ts

@@ -28,6 +28,25 @@ export const requestHook: RequestHook = async (url, opts) => {
   }
 }
 
+function constructUrl(start: string, query: StringMap = {}) {
+  let url: URL
+  let stripProtocol = false
+
+  try {
+    url = new URL(start)
+  } catch (_) {
+    url = new URL(`http://${start}`)
+    stripProtocol = true
+  }
+
+  for (const entry of Object.entries(query)) {
+    url.searchParams.append(...entry)
+  }
+
+  const str = url.toString()
+  return stripProtocol ? str.slice(7) : str
+}
+
 export const request = async (
   method: string,
   url: string,
@@ -36,14 +55,7 @@ export const request = async (
   bodyRaw: string,
   hook: RequestHook,
 ) => {
-  // construct url
-  const finalUrl = new URL(url)
-  if (blocks.query) {
-    for (const entry of Object.entries(blocks.query)) {
-      finalUrl.searchParams.append(...entry)
-    }
-  }
-  const urlString = finalUrl.toString()
+  const urlString = constructUrl(url, blocks.query)
 
   // construct headers
   const headers = new Headers(_headers)

packages/parser/src/passes/analyze.ts

@@ -3,15 +3,11 @@ import { ScopeTracker, transform } from '@getlang/walker'
 
 export function analyze(ast: Program) {
   const scope = new ScopeTracker()
-  const inputs = new Set<string>()
   const imports = new Set<string>()
   let isMacro = false
 
   transform(ast, {
     scope,
-    InputExpr(node) {
-      inputs.add(node.id.value)
-    },
     ModuleExpr(node) {
       imports.add(node.module.value)
     },
@@ -23,5 +19,5 @@ export function analyze(ast: Program) {
     },
   })
 
-  return { inputs, imports, isMacro }
+  return { imports, isMacro }
 }

packages/parser/src/passes/desugar.ts

@@ -5,6 +5,7 @@ import { dropDrills } from './desugar/dropdrill.js'
 import { settleLinks } from './desugar/links.js'
 import { RequestParsers } from './desugar/reqparse.js'
 import { insertSliceDeps } from './desugar/slicedeps.js'
+import { addUrlInputs } from './desugar/urlinputs.js'
 import { registerCalls } from './inference/calls.js'
 
 export type DesugarPass = (
@@ -15,21 +16,33 @@ export type DesugarPass = (
   },
 ) => Program
 
-function listCalls(ast: Program) {
+function analyze2(ast: Program) {
+  const inputs = new Set<string>()
   const calls = new Set<string>()
   const modifiers = new Set<string>()
+
   transform(ast, {
+    InputExpr(node) {
+      inputs.add(node.id.value)
+    },
     ModuleExpr(node) {
       node.call && calls.add(node.module.value)
     },
     ModifierExpr(node) {
       modifiers.add(node.modifier.value)
     },
   })
-  return { calls, modifiers }
+
+  return { inputs, calls, modifiers }
 }
 
-const visitors = [resolveContext, settleLinks, insertSliceDeps, dropDrills]
+const visitors = [
+  addUrlInputs,
+  resolveContext,
+  settleLinks,
+  insertSliceDeps,
+  dropDrills,
+]
 
 export function desugar(ast: Program, macros: string[] = []) {
   const parsers = new RequestParsers()
@@ -41,6 +54,6 @@ export function desugar(ast: Program, macros: string[] = []) {
   // inference pass `registerCalls` is included in the desugar phase
   // it produces the list of called modules required for type inference
   program = registerCalls(program, macros)
-  const { calls, modifiers } = listCalls(program)
-  return { program, calls, modifiers }
+  const info = analyze2(program)
+  return { program, ...info }
 }

packages/parser/src/passes/desugar/urlinputs.ts

@@ -0,0 +1,48 @@
+import type { TemplateExpr } from '@getlang/ast'
+import { isToken, t } from '@getlang/ast'
+import { ScopeTracker, transform } from '@getlang/walker'
+import { tx } from '../../utils.js'
+import type { DesugarPass } from '../desugar.js'
+
+export const addUrlInputs: DesugarPass = ast => {
+  const scope = new ScopeTracker()
+  const implied = new Set<string>()
+
+  return transform(ast, {
+    scope,
+
+    RequestExpr: {
+      enter(node) {
+        function walkUrl(t: TemplateExpr) {
+          for (const el of t.elements) {
+            if (isToken(el)) {
+              // continue
+            } else if (el.kind === 'TemplateExpr') {
+              walkUrl(el)
+            } else if (el.kind === 'IdentifierExpr') {
+              const id = el.id.value
+              if (el.isUrlComponent && !scope.vars[id]) {
+                implied.add(el.id.value)
+              }
+            }
+          }
+        }
+
+        walkUrl(node.url)
+      },
+    },
+
+    Program(node) {
+      if (implied.size) {
+        let decl = node.body.find(s => s.kind === 'DeclInputsStmt')
+        if (!decl) {
+          decl = t.declInputsStmt([])
+          node.body.unshift(decl)
+        }
+        for (const i of implied) {
+          decl.inputs.push(t.InputExpr(tx.token(i), false))
+        }
+      }
+    },
+  })
+}

test/expect.ts

@@ -1,31 +1,16 @@
 import { expect } from 'bun:test'
 import { diff } from 'jest-diff'
 
-async function toObject(req: Request) {
-  return {
-    url: req.url,
-    method: req.method,
-    headers: Object.fromEntries(req.headers),
-    body: await req.text(),
-  }
-}
-
 expect.extend({
-  async toHaveServed(received: unknown, expected: Request) {
-    const calls: [unknown][] = (received as any)?.mock?.calls
-    const expObj = await toObject(expected)
+  async toHaveServed(received: unknown, url: string, opts: RequestInit) {
+    const calls: [unknown, any][] = (received as any)?.mock?.calls
+    const { method, headers = {}, body } = opts
+    const expObj = { url, method, headers, body }
 
     let receivedObj: any
 
-    for (const [req] of calls) {
-      if (!(req instanceof Request)) {
-        return {
-          pass: false,
-          message: () => `Received non-Request object: ${req}`,
-        }
-      }
-
-      const recObj = await toObject(req)
+    for (const [url, { method, headers, body }] of calls) {
+      const recObj = { url, method, headers, body }
       receivedObj ??= recObj
       const pass = this.equals(recObj, expObj)
       if (pass) {

test/helpers.ts

@@ -13,7 +13,7 @@ type ExecuteOptions = Partial<{
   willThrow: boolean
 }>
 
-export type Fetch = (req: Request) => MaybePromise<Response>
+export type Fetch = (url: string, opts: RequestInit) => MaybePromise<Response>
 
 export const SELSYN = true
 
@@ -47,7 +47,7 @@ export async function execute(
     },
     async request(url, opts) {
       invariant(fetch, `Fetch required: ${url}`)
-      const res = await fetch(new Request(url, opts))
+      const res = await fetch(url, opts)
       return {
         status: res.status,
         headers: res.headers,