@pikku/cli 0.12.20 → 0.12.22

package/dist/src/functions/db/sqlite-codegen.js

@@ -0,0 +1,294 @@
+import { readFileSync, writeFileSync, mkdirSync, readdirSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+const SKIP_TABLES = new Set(['sqlite_sequence', 'sql_migrations']);
+function snakeToPascal(name) {
+    return name
+        .split('_')
+        .map((part) => part.charAt(0).toUpperCase() + part.slice(1).toLowerCase())
+        .join('');
+}
+function snakeToCamel(name) {
+    return name.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
+}
+function mapType(sqlType) {
+    const upper = sqlType.toUpperCase();
+    if (upper.includes('INT'))
+        return 'number';
+    if (upper.includes('CHAR') ||
+        upper.includes('CLOB') ||
+        upper.includes('TEXT')) {
+        return 'string';
+    }
+    if (upper.includes('BLOB'))
+        return 'Buffer';
+    if (upper.includes('REAL') ||
+        upper.includes('FLOA') ||
+        upper.includes('DOUB')) {
+        return 'number';
+    }
+    if (upper.includes('NUMERIC') || upper.includes('DECIMAL'))
+        return 'number';
+    if (upper.includes('BOOL'))
+        return 'number';
+    return 'string';
+}
+function listTables(db) {
+    const tableRows = db
+        .prepare(`SELECT name FROM sqlite_master
+         WHERE type = 'table'
+           AND name NOT LIKE 'sqlite\\_%' ESCAPE '\\'
+         ORDER BY name`)
+        .all();
+    return tableRows
+        .filter((t) => !SKIP_TABLES.has(t.name))
+        .map((t) => {
+        const allColumns = db
+            .prepare(`PRAGMA table_xinfo(${escapeIdentifier(t.name)})`)
+            .all();
+        // hidden: 0=regular, 2=virtual generated, 3=stored generated — include all; skip 1 (vtab hidden)
+        const columns = allColumns.filter((c) => c.hidden !== 1);
+        return { name: t.name, columns };
+    });
+}
+function escapeIdentifier(name) {
+    return `"${name.replace(/"/g, '""')}"`;
+}
+// ─── Annotation parsing ──────────────────────────────────────────────────────
+/**
+ * Determine column kind from naming conventions:
+ *   *_at / *_on            → date
+ *   is_* / has_* / can_*   → bool
+ */
+function annotationFromName(colName) {
+    if (/_at$|_on$/.test(colName))
+        return { kind: 'date' };
+    if (/^is_|^has_|^can_/.test(colName))
+        return { kind: 'bool' };
+    return null;
+}
+/**
+ * Parse `-- @bool | @date | @json [TypescriptType]` inline annotations from
+ * migration SQL files. The TypeScript type is optional and only meaningful for
+ * `@json` — it controls the generated TypeScript type (e.g. `string[]`,
+ * `Record<string, number>`).
+ *
+ * Returns an AnnotationMap: { table_name: { col_name: ColAnnotation } }.
+ */
+export function parseAnnotations(migrationsDir) {
+    let files;
+    try {
+        files = readdirSync(migrationsDir)
+            .filter((f) => f.endsWith('.sql'))
+            .sort();
+    }
+    catch {
+        return {};
+    }
+    const result = {};
+    for (const file of files) {
+        const content = readFileSync(join(migrationsDir, file), 'utf8');
+        const createTablePattern = /CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?"?(\w+)"?\s*\(([^;]+)\)/gis;
+        let tableMatch;
+        while ((tableMatch = createTablePattern.exec(content)) !== null) {
+            const tableName = tableMatch[1].toLowerCase();
+            const body = tableMatch[2];
+            for (const line of body.split('\n')) {
+                const trimmed = line.trim();
+                if (/^(PRIMARY|UNIQUE|CHECK|FOREIGN|CONSTRAINT)/i.test(trimmed))
+                    continue;
+                // Match: col_name TYPE ... -- @kind [optional ts type]
+                const annotationMatch = trimmed.match(/^(\w+)\s+\w.*?--\s*@(bool|date|json)(?:\s+(.+?))?$/i);
+                if (annotationMatch) {
+                    const colName = annotationMatch[1].toLowerCase();
+                    const kind = annotationMatch[2].toLowerCase();
+                    const tsType = annotationMatch[3]?.trim() || undefined;
+                    if (!result[tableName])
+                        result[tableName] = {};
+                    result[tableName][colName] = {
+                        kind,
+                        tsType: kind === 'json' ? tsType : undefined,
+                    };
+                }
+            }
+        }
+    }
+    return result;
+}
+/**
+ * Merge explicit SQL annotations with naming-convention-based ones.
+ * Explicit annotations take precedence.
+ */
+function buildAnnotationMap(tables, explicit) {
+    const merged = {};
+    for (const table of tables) {
+        const explicitCols = explicit[table.name] ?? {};
+        for (const col of table.columns) {
+            const annotation = explicitCols[col.name] ?? annotationFromName(col.name);
+            if (annotation) {
+                if (!merged[table.name])
+                    merged[table.name] = {};
+                merged[table.name][col.name] = annotation;
+            }
+        }
+    }
+    return merged;
+}
+// ─── Type expression ─────────────────────────────────────────────────────────
+function columnTypeExpression(col, annotation) {
+    const nullable = !col.notnull && col.pk === 0;
+    const hasDefault = col.dflt_value !== null && col.dflt_value !== undefined;
+    const isAutoInt = col.pk === 1 && mapType(col.type) === 'number';
+    const isGenerated = col.hidden === 2 || col.hidden === 3;
+    const wrap = (inner) => hasDefault || isAutoInt || isGenerated ? `Generated<${inner}>` : inner;
+    if (annotation?.kind === 'bool') {
+        const base = nullable ? 'boolean | null' : 'boolean';
+        const rw = nullable ? 'boolean | number | null' : 'boolean | number';
+        return wrap(`ColumnType<${base}, ${rw}, ${rw}>`);
+    }
+    if (annotation?.kind === 'date') {
+        const base = nullable ? 'Date | null' : 'Date';
+        const rw = nullable ? 'Date | string | null' : 'Date | string';
+        return wrap(`ColumnType<${base}, ${rw}, ${rw}>`);
+    }
+    if (annotation?.kind === 'json') {
+        const base = annotation.tsType
+            ? nullable
+                ? `${annotation.tsType} | null`
+                : annotation.tsType
+            : nullable
+                ? 'unknown | null'
+                : 'unknown';
+        return wrap(base);
+    }
+    // Default: plain SQL-mapped type
+    const base = mapType(col.type);
+    if (isAutoInt)
+        return `Generated<${base}>`;
+    if (hasDefault || isGenerated)
+        return `Generated<${base}${nullable ? ' | null' : ''}>`;
+    return nullable ? `${base} | null` : base;
+}
+// ─── Interface emitter ───────────────────────────────────────────────────────
+function emitInterface(table, camelCase, annotations) {
+    const ifaceName = snakeToPascal(table.name);
+    const tableCols = annotations[table.name] ?? {};
+    const fields = table.columns
+        .map((col) => {
+        const fieldName = camelCase ? snakeToCamel(col.name) : col.name;
+        const annotation = tableCols[col.name] ?? null;
+        const type = columnTypeExpression(col, annotation);
+        const safeName = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(fieldName)
+            ? fieldName
+            : JSON.stringify(fieldName);
+        return `  ${safeName}: ${type}`;
+    })
+        .join('\n');
+    return `export interface ${ifaceName} {\n${fields}\n}`;
+}
+/**
+ * Introspect the open SQLite database and emit a Kysely DB type to outFile
+ * plus a CoercionMap to coercionFile.
+ *
+ * Columns are annotated via:
+ *   1. Naming conventions (_at/_on → date; is_/has_/can_ → bool)
+ *   2. Inline SQL comments: `col_name TYPE ... -- @bool|@date|@json [TsType]`
+ *      For @json, an optional TypeScript type string controls the generated type.
+ *
+ * Returns `written: false` if the on-disk file already matches.
+ */
+export function generateSchemaTypes(db, options) {
+    const camelCase = options.camelCase ?? true;
+    const tables = listTables(db);
+    const explicitAnnotations = options.migrationsDir
+        ? parseAnnotations(options.migrationsDir)
+        : {};
+    const annotations = buildAnnotationMap(tables, explicitAnnotations);
+    // ── schema.d.ts ──
+    const interfaces = tables
+        .map((t) => emitInterface(t, camelCase, annotations))
+        .join('\n\n');
+    const dbEntries = tables
+        .map((t) => {
+        const tableKey = camelCase ? snakeToCamel(t.name) : t.name;
+        const safe = /^[a-zA-Z_][a-zA-Z0-9_]*$/.test(tableKey)
+            ? tableKey
+            : JSON.stringify(tableKey);
+        return `  ${safe}: ${snakeToPascal(t.name)}`;
+    })
+        .join('\n');
+    const schemaBody = [
+        `// Generated by @pikku/cli — do not edit by hand.`,
+        `// Run \`pikku db migrate\` to refresh.`,
+        ``,
+        `import type { ColumnType } from 'kysely'`,
+        ``,
+        `export type Generated<T> = T extends ColumnType<infer S, infer I, infer U>`,
+        `  ? ColumnType<S, I | undefined, U>`,
+        `  : ColumnType<T, T | undefined, T>`,
+        ``,
+        interfaces,
+        ``,
+        `export interface DB {`,
+        dbEntries,
+        `}`,
+        ``,
+    ].join('\n');
+    // ── coercion.gen.ts (runtime map — only kind, not tsType) ──
+    const runtimeMap = {};
+    for (const [table, cols] of Object.entries(annotations)) {
+        for (const [col, ann] of Object.entries(cols)) {
+            if (!runtimeMap[table])
+                runtimeMap[table] = {};
+            runtimeMap[table][col] = ann.kind;
+        }
+    }
+    const coercionEntries = Object.entries(runtimeMap)
+        .map(([table, cols]) => {
+        const colEntries = Object.entries(cols)
+            .map(([col, kind]) => `    "${col}": "${kind}"`)
+            .join(',\n');
+        return `  "${table}": {\n${colEntries}\n  }`;
+    })
+        .join(',\n');
+    const coercionBody = [
+        `// Generated by @pikku/cli — do not edit by hand.`,
+        `// Run \`pikku db migrate\` to refresh.`,
+        ``,
+        `export const coercionMap = {`,
+        coercionEntries,
+        `} as const`,
+        ``,
+    ].join('\n');
+    // ── write files ──
+    let existingSchema = null;
+    let existingCoercion = null;
+    try {
+        existingSchema = readFileSync(options.outFile, 'utf8');
+    }
+    catch {
+        /* ok */
+    }
+    try {
+        existingCoercion = readFileSync(options.coercionFile, 'utf8');
+    }
+    catch {
+        /* ok */
+    }
+    const schemaChanged = existingSchema !== schemaBody;
+    const coercionChanged = existingCoercion !== coercionBody;
+    if (schemaChanged) {
+        mkdirSync(dirname(options.outFile), { recursive: true });
+        writeFileSync(options.outFile, schemaBody, 'utf8');
+    }
+    if (coercionChanged) {
+        mkdirSync(dirname(options.coercionFile), { recursive: true });
+        writeFileSync(options.coercionFile, coercionBody, 'utf8');
+    }
+    return {
+        outFile: options.outFile,
+        coercionFile: options.coercionFile,
+        written: schemaChanged,
+        coercionWritten: coercionChanged,
+        tables: tables.map((t) => t.name),
+    };
+}

package/dist/src/functions/db/zod-codegen.d.ts

@@ -0,0 +1,10 @@
+export interface ZodCodegenOptions {
+    schemaFile: string;
+    outFile: string;
+}
+export interface ZodCodegenResult {
+    outFile: string;
+    written: boolean;
+    tables: string[];
+}
+export declare function generateZodTypes(options: ZodCodegenOptions): ZodCodegenResult;

package/dist/src/functions/db/zod-codegen.js

@@ -0,0 +1,109 @@
+import { mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+const INTERFACE_RE = /export\s+interface\s+(\w+)\s*\{([^}]*)\}/g;
+const FIELD_RE = /^\s*(\w+)\s*:\s*(.+?)\s*$/gm;
+export function generateZodTypes(options) {
+    const src = readFileSync(options.schemaFile, 'utf8');
+    const tables = parseTables(src);
+    const body = emitZodModule(tables);
+    let existing = null;
+    try {
+        existing = readFileSync(options.outFile, 'utf8');
+    }
+    catch {
+        // ok
+    }
+    const written = existing !== body;
+    if (written) {
+        mkdirSync(dirname(options.outFile), { recursive: true });
+        writeFileSync(options.outFile, body, 'utf8');
+    }
+    return {
+        outFile: options.outFile,
+        written,
+        tables: tables.map((table) => table.name),
+    };
+}
+function parseTables(src) {
+    const tables = [];
+    for (const match of src.matchAll(INTERFACE_RE)) {
+        const name = match[1];
+        if (name === 'DB')
+            continue;
+        const body = match[2];
+        const fields = [];
+        for (const field of body.matchAll(FIELD_RE)) {
+            fields.push({ name: field[1], type: field[2].trim() });
+        }
+        tables.push({ name, fields });
+    }
+    return tables;
+}
+function emitZodModule(tables) {
+    const lines = [];
+    lines.push('// Generated by @pikku/cli — do not edit by hand.');
+    lines.push('// Run `pikku db migrate` to refresh.');
+    lines.push('');
+    lines.push("import { z } from 'zod'");
+    lines.push('');
+    for (const table of tables) {
+        const rowFields = [];
+        const insertFields = [];
+        for (const field of table.fields) {
+            const { schema, generated } = zodForType(field.type);
+            rowFields.push(`  ${field.name}: ${schema},`);
+            insertFields.push(`  ${field.name}: ${schema}${generated ? '.optional()' : ''},`);
+        }
+        lines.push(`export const ${table.name}Z = z.object({`);
+        lines.push(...rowFields);
+        lines.push('})');
+        lines.push('');
+        lines.push(`export const ${table.name}InsertZ = z.object({`);
+        lines.push(...insertFields);
+        lines.push('})');
+        lines.push('');
+        lines.push(`export const ${table.name}PatchZ = ${table.name}Z.partial()`);
+        lines.push('');
+    }
+    return `${lines.join('\n')}\n`;
+}
+function zodForType(tsType) {
+    const generatedMatch = tsType.match(/^Generated<(.+)>$/);
+    const generated = generatedMatch !== null;
+    let inner = generated ? generatedMatch[1].trim() : tsType;
+    const nullable = inner.endsWith(' | null');
+    if (nullable) {
+        inner = inner.slice(0, -' | null'.length).trim();
+    }
+    let schema;
+    switch (inner) {
+        case 'string':
+            schema = 'z.string()';
+            break;
+        case 'number':
+            schema = 'z.number()';
+            break;
+        case 'boolean':
+            schema = 'z.boolean()';
+            break;
+        case 'Date':
+            schema = 'z.date()';
+            break;
+        case 'unknown':
+            schema = 'z.unknown()';
+            break;
+        default:
+            if (inner.endsWith('[]')) {
+                const item = zodForType(inner.slice(0, -2).trim()).schema;
+                schema = `z.array(${item})`;
+            }
+            else {
+                schema = 'z.unknown()';
+            }
+            break;
+    }
+    if (nullable) {
+        schema += '.nullable()';
+    }
+    return { schema, generated };
+}

package/dist/src/functions/runtimes/fetch/index.d.ts

@@ -1 +1 @@
-export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuFetch: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.d.ts

@@ -1 +1 @@
-export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "session" | "rpc", import("#pikku").PikkuFunctionSessionless<void, void, "session" | "rpc", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "session" | "rpc", import("#pikku").Services>, undefined, undefined>;
+export declare const pikkuNext: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;

package/dist/src/functions/runtimes/nextjs/pikku-command-nextjs.js

@@ -4,6 +4,7 @@ import { getFileImportRelativePath } from '../../../utils/file-import-path.js';
 import { writeFileInDir } from '../../../utils/file-writer.js';
 import { logCommandInfoAndTime } from '../../../middleware/log-command-info-and-time.js';
 import { serializeNextJsBackendWrapper as serializeNextBackendWrapper } from './serialize-nextjs-backend-wrapper.js';
+import { serializeNextJsBackendWorkerRPCWrapper as serializeNextBackendWorkerRPCWrapper } from './serialize-nextjs-backend-worker-rpc-wrapper.js';
 import { serializeNextJsHTTPWrapper as serializeNextHTTPWrapper } from './serialize-nextjs-http-wrapper.js';
 export const pikkuNext = pikkuSessionlessFunc({
     func: async ({ logger, config, getInspectorState }) => {
@@ -20,13 +21,31 @@ export const pikkuNext = pikkuSessionlessFunc({
             return;
         }
         const visitState = await getInspectorState();
-        if (nextHTTPFile && !fetchFile) {
+        const nextBackendTransport = config.clientFiles?.nextBackendTransport ?? 'local';
+        const nextBackendFetcherImport = config.clientFiles?.nextBackendFetcherImport;
+        if ((nextHTTPFile || nextBackendTransport === 'http') && !fetchFile) {
             throw new Error('fetchFile is required in pikku config in order for nextJS http wrapper to work');
         }
         if ((nextBackendFile || nextHTTPFile) && !rpcMapDeclarationFile) {
             throw new Error('rpcMapDeclarationFile is required in pikku config in order for nextJS wrapper to work');
         }
-        if (nextBackendFile) {
+        if (nextBackendFile && nextBackendTransport === 'http') {
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
+            const fetchPath = getFileImportRelativePath(nextBackendFile, fetchFile, packageMappings);
+            const content = serializeNextHTTPWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, fetchPath, config.globalHTTPPrefix || '', "process.env.PIKKU_DEV_MACHINE_API_BASE ?? 'http://127.0.0.1:4004'");
+            await writeFileInDir(logger, nextBackendFile, content);
+        }
+        else if (nextBackendFile && nextBackendTransport === 'worker-rpc') {
+            if (!nextBackendFetcherImport) {
+                throw new Error("clientFiles.nextBackendFetcherImport is required when nextBackendTransport === 'worker-rpc'");
+            }
+            const routesMapDeclarationPath = getFileImportRelativePath(nextBackendFile, httpMapDeclarationFile, packageMappings);
+            const rpcMapDeclarationPath = getFileImportRelativePath(nextBackendFile, rpcMapDeclarationFile, packageMappings);
+            const content = serializeNextBackendWorkerRPCWrapper(routesMapDeclarationPath, rpcMapDeclarationPath, nextBackendFetcherImport, config.globalHTTPPrefix || '');
+            await writeFileInDir(logger, nextBackendFile, content);
+        }
+        else if (nextBackendFile) {
             checkRequiredTypes(visitState.filesAndMethodsErrors, {
                 config: true,
                 singletonServicesFactory: true,

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-worker-rpc-wrapper.d.ts

@@ -0,0 +1 @@
+export declare const serializeNextJsBackendWorkerRPCWrapper: (routesMapPath: string, rpcMapPath: string, fetcherImportPath: string, globalHTTPPrefix?: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-backend-worker-rpc-wrapper.js

@@ -0,0 +1,163 @@
+export const serializeNextJsBackendWorkerRPCWrapper = (routesMapPath, rpcMapPath, fetcherImportPath, globalHTTPPrefix = '') => {
+    return `'server-only'
+
+/**
+ * Worker-RPC variant of the Next.js backend wrapper. Function code is NOT
+ * loaded in-process — every call is dispatched through the injected Fetcher.
+ * Generated by @pikku/cli (nextBackendTransport: 'worker-rpc').
+ */
+import { PikkuNextJSWorkerRPC } from '@pikku/next'
+import { NextRequest } from 'next/server.js'
+import type { HTTPWiringsMap, HTTPWiringHandlerOf, HTTPWiringsWithMethod } from '${routesMapPath}'
+import type { FlattenedRPCMap } from '${rpcMapPath}'
+import { fetcher } from '${fetcherImportPath}'
+
+type RouteContext = { params: Promise<Record<string, string | string[]>> }
+
+let _pikku: PikkuNextJSWorkerRPC | undefined
+let _removeAPIPrefix = true
+
+export const removeAPIPrefix = (enable: boolean) => {
+  _removeAPIPrefix = enable
+}
+
+export const pikku = (_options?: any) => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJSWorkerRPC({ fetcher })
+  }
+
+  const dynamicActionRequest = async <
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
+    return _pikku!.actionRequest(route, method, data as any)
+  }
+
+  const staticActionRequest = async <
+    Route extends keyof HTTPWiringsMap,
+    Method extends keyof HTTPWiringsMap[Route]
+  >(
+    route: Route,
+    method: Method,
+    data: HTTPWiringHandlerOf<Route, Method>['input'] = null
+  ): Promise<HTTPWiringHandlerOf<Route, Method>['output']> => {
+    return _pikku!.staticActionRequest(route, method, data as any)
+  }
+
+  const dynamicPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
+    return dynamicActionRequest(route, 'POST', args[0] ?? null)
+  }
+
+  const dynamicGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
+    return dynamicActionRequest(route, 'GET', args[0] ?? null)
+  }
+
+  const dynamicPatch = <Route extends HTTPWiringsWithMethod<'PATCH'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'PATCH'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'PATCH'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'PATCH'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'PATCH'>['output']> => {
+    return dynamicActionRequest(route, 'PATCH', args[0] ?? null)
+  }
+
+  const dynamicDel = <Route extends HTTPWiringsWithMethod<'DELETE'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'DELETE'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'DELETE'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'DELETE'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'DELETE'>['output']> => {
+    return dynamicActionRequest(route, 'DELETE', args[0] ?? null)
+  }
+
+  const staticPost = <Route extends HTTPWiringsWithMethod<'POST'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'POST'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'POST'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'POST'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'POST'>['output']> => {
+    return staticActionRequest(route, 'POST', args[0] ?? null)
+  }
+
+  const staticGet = <Route extends HTTPWiringsWithMethod<'GET'>>(
+    route: Route,
+    ...args: HTTPWiringHandlerOf<Route, 'GET'>['input'] extends null | undefined
+      ? [data?: HTTPWiringHandlerOf<Route, 'GET'>['input']]
+      : [data: NonNullable<HTTPWiringHandlerOf<Route, 'GET'>['input']>]
+  ): Promise<HTTPWiringHandlerOf<Route, 'GET'>['output']> => {
+    return staticActionRequest(route, 'GET', args[0] ?? null)
+  }
+
+  // RPC dispatch goes through the underlying actionRequest (route: unknown)
+  // rather than the typed dynamic/static wrappers — '/rpc/:rpcName' isn't
+  // necessarily registered as an HTTPWiringsMap key in projects that haven't
+  // explicitly wired one. Output type is enforced via FlattenedRPCMap.
+  const rpc = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return _pikku!.actionRequest(
+      '${globalHTTPPrefix}/rpc/:rpcName',
+      'POST',
+      { rpcName, data: data ?? null }
+    ) as Promise<FlattenedRPCMap[Name]['output']>
+  }
+
+  const staticRPC = async <Name extends keyof FlattenedRPCMap>(
+    rpcName: Name,
+    data: FlattenedRPCMap[Name]['input']
+  ): Promise<FlattenedRPCMap[Name]['output']> => {
+    return _pikku!.staticActionRequest(
+      '${globalHTTPPrefix}/rpc/:rpcName',
+      'POST',
+      { rpcName, data: data ?? null }
+    ) as Promise<FlattenedRPCMap[Name]['output']>
+  }
+
+  return {
+    rpc,
+    get: dynamicGet,
+    post: dynamicPost,
+    patch: dynamicPatch,
+    del: dynamicDel,
+    staticGet,
+    staticPost,
+    staticRPC,
+  }
+}
+
+export const pikkuAPIRequest = (
+  req: NextRequest,
+  context: RouteContext
+): Promise<Response> => {
+  if (!_pikku) {
+    _pikku = new PikkuNextJSWorkerRPC({ fetcher })
+  }
+  if (_removeAPIPrefix) {
+    const url = new URL(req.url)
+    url.pathname = url.pathname.replace(/^\\/api/, '') || '/'
+    req = new NextRequest(url.toString(), {
+      method: req.method,
+      headers: req.headers,
+      body: req.body,
+      duplex: 'half',
+    } as any)
+  }
+  return _pikku.apiRequest(req)
+}
+`;
+};

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.d.ts

@@ -1 +1 @@
-export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string, globalHTTPPrefix?: string) => string;
+export declare const serializeNextJsHTTPWrapper: (routesMapPath: string, rpcMapPath: string, pikkuFetchImport: string, globalHTTPPrefix?: string, defaultServerUrlExpression?: string) => string;

package/dist/src/functions/runtimes/nextjs/serialize-nextjs-http-wrapper.js

@@ -1,4 +1,4 @@
-export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport, globalHTTPPrefix = '') => {
+export const serializeNextJsHTTPWrapper = (routesMapPath, rpcMapPath, pikkuFetchImport, globalHTTPPrefix = '', defaultServerUrlExpression) => {
     return `'server-only'
   
 /**
@@ -11,6 +11,7 @@ import type { FlattenedRPCMap } from '${rpcMapPath}'
 import { PikkuFetch } from '${pikkuFetchImport}'
 
 let _pikku: PikkuFetch | undefined
+const defaultServerUrl = ${defaultServerUrlExpression ?? 'undefined'}
 
 /**
  * Initializes and returns an instance of PikkuNextJS with helper methods for handling route requests.
@@ -19,7 +20,9 @@ let _pikku: PikkuFetch | undefined
  */
 export const pikku = (options?: CorePikkuFetchOptions) => {
   if (!_pikku) {
-    _pikku = new PikkuFetch(options)
+    _pikku = new PikkuFetch(
+      defaultServerUrl ? { serverUrl: defaultServerUrl, ...options } : options
+    )
   }
 
   const dynamicActionRequest = async <

package/dist/src/functions/runtimes/tanstack-start/pikku-command-tanstack-start.d.ts

@@ -0,0 +1 @@
+export declare const pikkuTanStackStart: import("#pikku").PikkuFunctionConfig<void, void, "rpc" | "session", import("#pikku").PikkuFunctionSessionless<void, void, "rpc" | "session", import("#pikku").Services> | import("#pikku").PikkuFunction<void, void, "rpc" | "session", import("#pikku").Services>, undefined, undefined>;