ts-ag 0.0.1-dev.1

package/README.md

@@ -0,0 +1,6 @@
+### Typescript
+
+Although shadcn exists here in the repo it is not shipped. This is simply for tooling and nothing else, as such in the
+`svelte.config.js` the aliases are added just for typescript, so that they are not resolved by the packaging process.
+
+This allows consumers to bring their own shadcn components just so long as they resolve `$shadcn`

package/dist/browser.d.ts

@@ -0,0 +1,2 @@
+export * from './lambda/browser.js';
+//# sourceMappingURL=browser.d.ts.map

package/dist/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../src/browser.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}

package/dist/browser.js

@@ -0,0 +1 @@
+export * from './lambda/browser.js';

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+export * from './lambda/index.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC"}

package/dist/index.js

@@ -0,0 +1 @@
+export * from './lambda/index.js';

package/dist/lambda/browser.d.ts

@@ -0,0 +1,4 @@
+export * from './client-types.js';
+export * from './client.js';
+export * from './handlerUtils.js';
+//# sourceMappingURL=browser.d.ts.map

package/dist/lambda/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/lambda/browser.ts"],"names":[],"mappings":"AAAA,cAAc,mBAAmB,CAAC;AAClC,cAAc,aAAa,CAAC;AAC5B,cAAc,mBAAmB,CAAC"}

package/dist/lambda/browser.js

@@ -0,0 +1,3 @@
+export * from './client-types.js';
+export * from './client.js';
+export * from './handlerUtils.js';

package/dist/lambda/client-types.d.ts

@@ -0,0 +1,74 @@
+/**
+ * Converts a RawApiGatewayHandler response type to a fetch like response type.
+ */
+type ConvertToFetch<T> = T extends {
+    statusCode: number;
+    body: object;
+    headers: object;
+} ? {
+    ok: T['statusCode'] extends 200 | 201 | 204 ? true : false;
+    json: () => Promise<T['body']>;
+    status: T['statusCode'];
+} : T;
+export type CleanResponse = Omit<Response, 'status' | 'ok' | 'json'>;
+export type FetchResponse<T extends (...args: any) => any> = ConvertToFetch<Awaited<ReturnType<T>>> & CleanResponse;
+/**
+ * Extracts the requestInput type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiInput<E extends {
+    path: string;
+    method: string;
+    requestInput: any;
+}, P extends E['path'], M extends E['method']> = Extract<E, {
+    path: P;
+    method: M;
+}>['requestInput'];
+/**
+ * Extracts the requestOutput type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiOutput<E extends {
+    path: string;
+    method: string;
+    requestOutput: any;
+}, P extends E['path'], M extends E['method']> = Extract<E, {
+    path: P;
+    method: M;
+}>['requestOutput'];
+/**
+ * Extracts the response type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiResponse<E extends {
+    path: string;
+    method: string;
+    response: any;
+}, P extends E['path'], M extends E['method']> = Extract<E, {
+    path: P;
+    method: M;
+}>['response'];
+/**
+ * Extracts the sucessful body type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiSuccessBody<E extends {
+    path: string;
+    method: string;
+    response: any;
+}, P extends E['path'], M extends E['method']> = Extract<Extract<E, {
+    path: P;
+    method: M;
+}>['response'], {
+    status: 200;
+}>['json'] extends () => Promise<infer R> ? R : unknown;
+export {};
+//# sourceMappingURL=client-types.d.ts.map

package/dist/lambda/client-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client-types.d.ts","sourceRoot":"","sources":["../../src/lambda/client-types.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,KAAK,cAAc,CAAC,CAAC,IAAI,CAAC,SAAS;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GACpF;IACE,EAAE,EAAE,CAAC,CAAC,YAAY,CAAC,SAAS,GAAG,GAAG,GAAG,GAAG,GAAG,GAAG,IAAI,GAAG,KAAK,CAAC;IAC3D,IAAI,EAAE,MAAM,OAAO,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;IAC/B,MAAM,EAAE,CAAC,CAAC,YAAY,CAAC,CAAC;CACzB,GACD,CAAC,CAAC;AAEN,MAAM,MAAM,aAAa,GAAG,IAAI,CAAC,QAAQ,EAAE,QAAQ,GAAG,IAAI,GAAG,MAAM,CAAC,CAAC;AACrE,MAAM,MAAM,aAAa,CAAC,CAAC,SAAS,CAAC,GAAG,IAAI,EAAE,GAAG,KAAK,GAAG,IAAI,cAAc,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,aAAa,CAAC;AAEpH;;;;;GAKG;AACH,MAAM,MAAM,QAAQ,CAClB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,GAAG,CAAA;CAAE,EAC7D,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EACnB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,IACnB,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC,cAAc,CAAC,CAAC;AAEvD;;;;;GAKG;AACH,MAAM,MAAM,SAAS,CACnB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,GAAG,CAAA;CAAE,EAC9D,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EACnB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,IACnB,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC,eAAe,CAAC,CAAC;AAExD;;;;;GAKG;AACH,MAAM,MAAM,WAAW,CACrB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,EACzD,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EACnB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,IACnB,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC,UAAU,CAAC,CAAC;AAEnD;;;;;GAKG;AACH,MAAM,MAAM,cAAc,CACxB,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,EACzD,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,EACnB,CAAC,SAAS,CAAC,CAAC,QAAQ,CAAC,IACnB,OAAO,CAAC,OAAO,CAAC,CAAC,EAAE;IAAE,IAAI,EAAE,CAAC,CAAC;IAAC,MAAM,EAAE,CAAC,CAAA;CAAE,CAAC,CAAC,UAAU,CAAC,EAAE;IAAE,MAAM,EAAE,GAAG,CAAA;CAAE,CAAC,CAAC,MAAM,CAAC,SAAS,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC,GAC/G,CAAC,GACD,OAAO,CAAC"}

package/dist/lambda/client-types.js

@@ -0,0 +1 @@
+export {};

package/dist/lambda/client.d.ts

@@ -0,0 +1,26 @@
+import * as v from 'valibot';
+import type { ApiInput, ApiResponse } from './client-types.js';
+declare const HTTPMethods: readonly ["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS", "HEAD"];
+type HTTPMethod = (typeof HTTPMethods)[number];
+export type ApiRequestFunction<API extends {
+    path: string;
+    method: string;
+    requestInput: any;
+    requestOutput: any;
+    response: any;
+}> = <Path extends API['path'], Method extends Extract<API, {
+    path: Path;
+}>['method']>(path: Path, method: Method, input: ApiInput<API, Path, Method>, headers?: HeadersInit) => Promise<ApiResponse<API, Path, Method>>;
+/**
+ * @returns A function that can be used to make API requests with type safety
+ * @example const clientApiRequest = createApiRequest<ApiEndpoints>();
+ */
+export declare function createApiRequest<API extends {
+    path: string;
+    method: string;
+    requestInput: any;
+    requestOutput: any;
+    response: any;
+}>(schemas: Partial<Record<API['path'], Partial<Record<HTTPMethod, v.GenericSchema | (() => v.GenericSchema)>>>>, apiUrl: string, env: string): ApiRequestFunction<API>;
+export {};
+//# sourceMappingURL=client.d.ts.map

package/dist/lambda/client.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../../src/lambda/client.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,CAAC,MAAM,SAAS,CAAC;AAC7B,OAAO,KAAK,EAAE,QAAQ,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAuD/D,QAAA,MAAM,WAAW,uEAAwE,CAAC;AAC1F,KAAK,UAAU,GAAG,CAAC,OAAO,WAAW,CAAC,CAAC,MAAM,CAAC,CAAC;AAE/C,MAAM,MAAM,kBAAkB,CAC5B,GAAG,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,GAAG,CAAC;IAAC,aAAa,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,IAChG,CAAC,IAAI,SAAS,GAAG,CAAC,MAAM,CAAC,EAAE,MAAM,SAAS,OAAO,CAAC,GAAG,EAAE;IAAE,IAAI,EAAE,IAAI,CAAA;CAAE,CAAC,CAAC,QAAQ,CAAC,EAClF,IAAI,EAAE,IAAI,EACV,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,EAClC,OAAO,CAAC,EAAE,WAAW,KAClB,OAAO,CAAC,WAAW,CAAC,GAAG,EAAE,IAAI,EAAE,MAAM,CAAC,CAAC,CAAC;AAE7C;;;GAGG;AACH,wBAAgB,gBAAgB,CAC9B,GAAG,SAAS;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,YAAY,EAAE,GAAG,CAAC;IAAC,aAAa,EAAE,GAAG,CAAC;IAAC,QAAQ,EAAE,GAAG,CAAA;CAAE,EAElG,OAAO,EAAE,OAAO,CAAC,MAAM,CAAC,GAAG,CAAC,MAAM,CAAC,EAAE,OAAO,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC,CAAC,aAAa,GAAG,CAAC,MAAM,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,CAAC,CAAC,EAC7G,MAAM,EAAE,MAAM,EACd,GAAG,EAAE,MAAM,GACV,kBAAkB,CAAC,GAAG,CAAC,CAkBzB"}

package/dist/lambda/client.js

@@ -0,0 +1,53 @@
+import { deserialize } from './deserializer.js';
+import * as v from 'valibot';
+const bodyMethods = ['POST', 'PUT', 'PATCH'];
+const queryMethods = ['GET', 'DELETE'];
+async function _apiRequest(path, method, input, schema, environment, apiUrl, headers) {
+    if (schema) {
+        v.parse(schema, input);
+    }
+    let url = `${apiUrl}${path}`;
+    if (queryMethods.includes(method)) {
+        const params = input ?? {};
+        const queryString = new URLSearchParams(Object.entries(params).reduce((acc, [key, value]) => {
+            if (Array.isArray(value)) {
+                value.forEach((v) => (acc[key] = String(v)));
+            }
+            else {
+                acc[key] = String(value);
+            }
+            return acc;
+        }, {})).toString();
+        if (queryString)
+            url += `?${queryString}`;
+    }
+    headers = {
+        'Content-Type': 'application/json',
+        ...(headers || {})
+    };
+    const response = await fetch(url, {
+        method,
+        headers,
+        body: bodyMethods.includes(method) ? JSON.stringify(input) : undefined,
+        credentials: 'include'
+    });
+    response.json = async () => {
+        return await deserialize(await response.text(), environment);
+    };
+    return response;
+}
+const HTTPMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'];
+/**
+ * @returns A function that can be used to make API requests with type safety
+ * @example const clientApiRequest = createApiRequest<ApiEndpoints>();
+ */
+export function createApiRequest(schemas, apiUrl, env) {
+    return async function apiRequest(path, method, input, headers) {
+        // @ts-expect-error method can be used to index schemas
+        let schema = schemas[path]?.[method];
+        if (typeof schema === 'function') {
+            schema = schema();
+        }
+        return _apiRequest(path, method, input, schema, env, apiUrl, headers);
+    };
+}

package/dist/lambda/deserializer.d.ts

@@ -0,0 +1,3 @@
+declare function deserialize(data: string, env: string | 'production'): Promise<any>;
+export { deserialize };
+//# sourceMappingURL=deserializer.d.ts.map

package/dist/lambda/deserializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"deserializer.d.ts","sourceRoot":"","sources":["../../src/lambda/deserializer.ts"],"names":[],"mappings":"AAAA,iBAAe,WAAW,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,GAAG,OAAO,CAAC,GAAG,CAAC,CAQjF;AAED,OAAO,EAAE,WAAW,EAAE,CAAC"}

package/dist/lambda/deserializer.js

@@ -0,0 +1,11 @@
+async function deserialize(data, env) {
+    if (env === 'production') {
+        const { parse: prodParse } = await import('@ungap/structured-clone/json');
+        return prodParse(data);
+    }
+    else {
+        const cycle = await import('cycle');
+        return JSON.parse(cycle.default.retrocycle(data));
+    }
+}
+export { deserialize };

package/dist/lambda/handlerUtils.d.ts

@@ -0,0 +1,31 @@
+import type { APIGatewayProxyResultV2, Context } from 'aws-lambda';
+/**
+ * A type for the raw proxy result - just using an object not a stirng for the body
+ */
+export type RawProxyResultV2 = {
+    statusCode?: number | undefined;
+    headers?: {
+        [header: string]: boolean | number | string;
+    } | undefined;
+    body?: object | undefined;
+    isBase64Encoded?: boolean | undefined;
+    cookies?: string[] | undefined;
+};
+export type APIGatewayHandler<E> = (event: E, context: Context) => Promise<APIGatewayProxyResultV2>;
+export type RawApiGatewayHandler<E> = (event: E, context: Context) => Promise<RawProxyResultV2>;
+/**
+ * Wraps a handler that returns the body as an object rather than a string.
+ *
+ * This means you can achieve proper type inference on your handler and have standardised serialisation
+ *
+ * @example
+```ts
+export type AuthorizerContext = {
+  details: JWTPayload;
+} | null;
+
+export const wrapHandler = baseWrapHandler<APIGatewayProxyEventV2WithLambdaAuthorizer<AuthorizerContext>>
+
+*/
+export declare function wrapHandler<E>(handler: RawApiGatewayHandler<E>): APIGatewayHandler<E>;
+//# sourceMappingURL=handlerUtils.d.ts.map

package/dist/lambda/handlerUtils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"handlerUtils.d.ts","sourceRoot":"","sources":["../../src/lambda/handlerUtils.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,uBAAuB,EAAE,OAAO,EAAE,MAAM,YAAY,CAAC;AAGnE;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,OAAO,CAAC,EACJ;QACE,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,CAAC;KAC7C,GACD,SAAS,CAAC;IACd,IAAI,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IAC1B,eAAe,CAAC,EAAE,OAAO,GAAG,SAAS,CAAC;IACtC,OAAO,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;CAChC,CAAC;AAGF,MAAM,MAAM,iBAAiB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,uBAAuB,CAAC,CAAC;AAGpG,MAAM,MAAM,oBAAoB,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,CAAC,EAAE,OAAO,EAAE,OAAO,KAAK,OAAO,CAAC,gBAAgB,CAAC,CAAC;AAEhG;;;;;;;;;;;;;EAaE;AACF,wBAAgB,WAAW,CAAC,CAAC,EAAE,OAAO,EAAE,oBAAoB,CAAC,CAAC,CAAC,GAAG,iBAAiB,CAAC,CAAC,CAAC,CAQrF"}

package/dist/lambda/handlerUtils.js

@@ -0,0 +1,24 @@
+import { stringify } from './serializer.js';
+/**
+ * Wraps a handler that returns the body as an object rather than a string.
+ *
+ * This means you can achieve proper type inference on your handler and have standardised serialisation
+ *
+ * @example
+```ts
+export type AuthorizerContext = {
+  details: JWTPayload;
+} | null;
+
+export const wrapHandler = baseWrapHandler<APIGatewayProxyEventV2WithLambdaAuthorizer<AuthorizerContext>>
+
+*/
+export function wrapHandler(handler) {
+    return async (event, context) => {
+        const result = await handler(event, context);
+        return {
+            ...result,
+            body: result.body ? await stringify(result.body) : undefined
+        };
+    };
+}

package/dist/lambda/index.d.ts

@@ -0,0 +1,2 @@
+export * from './browser.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/lambda/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lambda/index.ts"],"names":[],"mappings":"AAAA,cAAc,cAAc,CAAC"}

package/dist/lambda/index.js

@@ -0,0 +1 @@
+export * from './browser.js';

package/dist/lambda/serializer.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Turns object into string.
+ *
+ * Uses different methods in production and otherwise for more readable output
+ */
+export declare function stringify(data: any): Promise<any>;
+//# sourceMappingURL=serializer.d.ts.map

package/dist/lambda/serializer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serializer.d.ts","sourceRoot":"","sources":["../../src/lambda/serializer.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,GAAG,gBAQxC"}

package/dist/lambda/serializer.js

@@ -0,0 +1,15 @@
+/**
+ * Turns object into string.
+ *
+ * Uses different methods in production and otherwise for more readable output
+ */
+export async function stringify(data) {
+    if (process.env.PUBLIC_ENVIRONMENT === 'production') {
+        const { stringify: prodStrigify } = await import('@ungap/structured-clone/json');
+        return prodStrigify(data);
+    }
+    else {
+        const { decycle } = (await import('cycle')).default;
+        return JSON.stringify(decycle(data), null);
+    }
+}

package/dist/ts-alias.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=ts-alias.d.ts.map

package/dist/ts-alias.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-alias.d.ts","sourceRoot":"","sources":["../src/ts-alias.ts"],"names":[],"mappings":""}

package/dist/ts-alias.js

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+import * as fs from 'fs';
+import * as path from 'path';
+import * as chokidar from 'chokidar';
+import { replaceTscAliasPaths } from 'tsc-alias';
+import { glob } from 'glob';
+import console from 'console';
+// Cache for tsconfig.json files
+const tsconfigCache = new Map();
+// Parse command-line arguments
+const args = process.argv.slice(2);
+const watchMode = args.includes('-w') || args.includes('--watch');
+/**
+ * Find all dist folders in the project directory, excluding certain patterns.
+ */
+async function findDistFolders(baseDir) {
+    const ignorePatterns = [
+        '**/node_modules/**',
+        '**/\\.git/**',
+        '**/\\.vscode/**',
+        '**/\\.idea/**',
+        '**/coverage/**',
+        '**/build/**',
+        '**/cdk.out/**'
+    ];
+    const distFolders = await glob('**/dist', {
+        cwd: baseDir,
+        ignore: ignorePatterns,
+        absolute: true
+    });
+    return distFolders;
+}
+/**
+ * Get the tsconfig.json file for a given dist folder.
+ * This function caches the tsconfig file to avoid reading it multiple times.
+ */
+function getTsconfig(distFolder) {
+    const projectRoot = path.dirname(distFolder);
+    const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+    try {
+        const stats = fs.statSync(tsconfigPath);
+        const mtime = stats.mtimeMs;
+        // Check cache
+        const cached = tsconfigCache.get(tsconfigPath);
+        if (cached && cached.mtime === mtime) {
+            return cached.config;
+        }
+        // Read and cache the config
+        const config = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'));
+        tsconfigCache.set(tsconfigPath, { config, mtime });
+        return config;
+    }
+    catch (error) {
+        console.error(`Error reading tsconfig at ${tsconfigPath}:`, error);
+        return null;
+    }
+}
+/**
+ * Process the dist folder by replacing TypeScript alias paths with relative paths.
+ */
+async function processDistFolder(distFolder) {
+    const projectRoot = path.dirname(distFolder);
+    const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+        console.warn(`No tsconfig.json found at ${tsconfigPath}`);
+        return;
+    }
+    const tsconfig = getTsconfig(distFolder);
+    if (!tsconfig) {
+        console.warn(`Invalid tsconfig.json found for ${distFolder}`);
+        return;
+    }
+    try {
+        await replaceTscAliasPaths({
+            configFile: tsconfigPath,
+            outDir: distFolder
+        });
+        console.log(`Successfully processed aliases in ${distFolder}`);
+    }
+    catch (error) {
+        console.error(`Error processing aliases in ${distFolder}:`, error);
+    }
+}
+/**
+ * Watch the dist folder for changes and process it when files are added or changed.
+ */
+function watchDistFolder(distFolder) {
+    console.log(`Setting up watcher for: ${distFolder}`);
+    const watcher = chokidar.watch(distFolder, {
+        persistent: true,
+        ignoreInitial: true,
+        awaitWriteFinish: {
+            stabilityThreshold: 300,
+            pollInterval: 100
+        }
+    });
+    watcher.on('add', (filePath) => {
+        if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+            console.log(`File added: ${filePath}`);
+            processDistFolder(distFolder);
+        }
+    });
+    watcher.on('change', (filePath) => {
+        if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+            console.log(`File changed: ${filePath}`);
+            processDistFolder(distFolder);
+        }
+    });
+    return watcher;
+}
+// Main function
+async function main() {
+    const baseDir = process.cwd();
+    console.log(`Searching for dist folders in: ${baseDir}`);
+    const distFolders = await findDistFolders(baseDir);
+    // Process all folders initially if any exist
+    if (distFolders.length > 0) {
+        console.log(`Found ${distFolders.length} dist folders:`);
+        distFolders.forEach((folder) => console.log(` - ${folder}`));
+        for (const folder of distFolders) {
+            await processDistFolder(folder);
+        }
+    }
+    else {
+        console.log('No dist folders found initially');
+    }
+    // Set up watchers if in watch mode
+    if (watchMode) {
+        console.log('Watch mode enabled, monitoring for changes...');
+        // Set up watchers for existing dist folders
+        distFolders.forEach(watchDistFolder);
+        // Watch for new dist folders being created
+        console.log('Watching for new dist folders...');
+        const dirWatcher = chokidar.watch(baseDir, {
+            persistent: true,
+            ignoreInitial: true,
+            depth: 5, // Adjust depth as needed for your project structure
+            ignored: [
+                '**/node_modules/**',
+                '**/\\.git/**',
+                '**/\\.vscode/**',
+                '**/\\.idea/**',
+                '**/coverage/**',
+                '**/build/**',
+                '**/cdk.out/**',
+                // Don't watch the contents of existing dist folders (they'll be watched separately)
+                ...distFolders.map((folder) => `${folder}/**`)
+            ]
+        });
+        // Handle directory creation events
+        dirWatcher.on('addDir', async (dirPath) => {
+            if (path.basename(dirPath) === 'dist') {
+                // Make sure it's not already being watched
+                if (!distFolders.includes(dirPath)) {
+                    console.log(`New dist folder detected: ${dirPath}`);
+                    distFolders.push(dirPath);
+                    await processDistFolder(dirPath);
+                    watchDistFolder(dirPath);
+                }
+            }
+        });
+    }
+}
+main().catch((error) => {
+    console.error('Error in ts-alias script:', error);
+    process.exit(1);
+});

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "ts-ag",
+  "description": "Useful TS stuff",
+  "version": "0.0.1-dev.1",
+  "author": "Alexander Hornung",
+  "bugs": "https://github.com/ageorgeh/ts-ag/issues",
+  "dependencies": {
+    "dequal": "^2.0.3",
+    "glob": "11.0.2",
+    "chokidar": "4.0.3",
+    "tsc-alias": "1.8.16",
+    "valibot": "1.1.0",
+    "cycle": "1.0.3",
+    "@ungap/structured-clone": "1.3.0",
+    "jose": "6.0.11"
+  },
+  "peerDependencies": {},
+  "devDependencies": {
+    "jiti": "2.4.2",
+    "@eslint/js": "^9.26.0",
+    "eslint": "^9.26.0",
+    "eslint-plugin-import": "^2.31.0",
+    "globals": "^16.1.0",
+    "prettier": "^3.5.3",
+    "typescript": "^5.8.3",
+    "typescript-eslint": "^8.32.0",
+    "typescript-svelte-plugin": "0.3.47",
+    "npm-check-updates": "^18.0.1",
+    "@types/node": "^22.15.17",
+    "@types/aws-lambda": "8.10.149",
+    "@types/ungap__structured-clone": "1.2.0"
+  },
+  "type": "module",
+  "files": [
+    "./src",
+    "./dist"
+  ],
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "browser": {
+        "types": "./dist/browser.d.ts",
+        "default": "./dist/browser.js"
+      },
+      "default": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      }
+    }
+  },
+  "repository": "ageorgeh/ts-ag",
+  "scripts": {
+    "tsc:build": "tsc",
+    "tsc:watch": "tsc --watch",
+    "publish:local": "pnpm version prerelease --preid dev --no-git-tag-version && pnpm publish --registry http://localhost:4873 --tag dev --access public --no-git-checks --json > ./publishLocal.json",
+    "publish:prerelease": "pnpm publish --tag dev --access public --no-git-checks --registry=https://registry.npmjs.org/ --json > ./publish.json",
+    "version:prerelease": "pnpm version prerelease --preid dev --no-git-tag-version"
+  }
+}

package/src/browser.ts

@@ -0,0 +1 @@
+export * from './lambda/browser.js';

package/src/index.ts

@@ -0,0 +1 @@
+export * from './lambda/index.js';

package/src/lambda/browser.ts

@@ -0,0 +1,3 @@
+export * from './client-types.js';
+export * from './client.js';
+export * from './handlerUtils.js';

package/src/lambda/client-types.ts

@@ -0,0 +1,63 @@
+/**
+ * Converts a RawApiGatewayHandler response type to a fetch like response type.
+ */
+type ConvertToFetch<T> = T extends { statusCode: number; body: object; headers: object }
+  ? {
+      ok: T['statusCode'] extends 200 | 201 | 204 ? true : false;
+      json: () => Promise<T['body']>;
+      status: T['statusCode'];
+    }
+  : T;
+
+export type CleanResponse = Omit<Response, 'status' | 'ok' | 'json'>;
+export type FetchResponse<T extends (...args: any) => any> = ConvertToFetch<Awaited<ReturnType<T>>> & CleanResponse;
+
+/**
+ * Extracts the requestInput type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiInput<
+  E extends { path: string; method: string; requestInput: any },
+  P extends E['path'],
+  M extends E['method']
+> = Extract<E, { path: P; method: M }>['requestInput'];
+
+/**
+ * Extracts the requestOutput type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiOutput<
+  E extends { path: string; method: string; requestOutput: any },
+  P extends E['path'],
+  M extends E['method']
+> = Extract<E, { path: P; method: M }>['requestOutput'];
+
+/**
+ * Extracts the response type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiResponse<
+  E extends { path: string; method: string; response: any },
+  P extends E['path'],
+  M extends E['method']
+> = Extract<E, { path: P; method: M }>['response'];
+
+/**
+ * Extracts the sucessful body type from an API endpoint definition
+ * @template E - Union type of all API endpoints
+ * @template P - Path string literal type (e.g. 'payments/account')
+ * @template M - HTTP method string literal type (e.g. 'GET', 'POST')
+ */
+export type ApiSuccessBody<
+  E extends { path: string; method: string; response: any },
+  P extends E['path'],
+  M extends E['method']
+> = Extract<Extract<E, { path: P; method: M }>['response'], { status: 200 }>['json'] extends () => Promise<infer R>
+  ? R
+  : unknown;

package/src/lambda/client.ts

@@ -0,0 +1,98 @@
+import { deserialize } from './deserializer.js';
+import * as v from 'valibot';
+import type { ApiInput, ApiResponse } from './client-types.js';
+
+const bodyMethods = ['POST', 'PUT', 'PATCH'] as const;
+const queryMethods = ['GET', 'DELETE'] as const;
+
+async function _apiRequest<T = Response>(
+  path: string,
+  method: 'GET' | 'POST' | 'DELETE',
+  input: object,
+  schema: v.GenericSchema | undefined,
+  environment: string | 'production',
+  apiUrl: string,
+  headers?: HeadersInit
+): Promise<T> {
+  if (schema) {
+    v.parse(schema, input);
+  }
+
+  let url = `${apiUrl}${path}`;
+
+  if (queryMethods.includes(method as any)) {
+    const params = input ?? {};
+    const queryString = new URLSearchParams(
+      Object.entries(params).reduce(
+        (acc, [key, value]) => {
+          if (Array.isArray(value)) {
+            value.forEach((v) => (acc[key] = String(v)));
+          } else {
+            acc[key] = String(value);
+          }
+          return acc;
+        },
+        {} as Record<string, string>
+      )
+    ).toString();
+    if (queryString) url += `?${queryString}`;
+  }
+
+  headers = {
+    'Content-Type': 'application/json',
+    ...(headers || {})
+  };
+  const response = await fetch(url, {
+    method,
+    headers,
+    body: bodyMethods.includes(method as any) ? JSON.stringify(input) : undefined,
+    credentials: 'include'
+  });
+
+  response.json = async () => {
+    return await deserialize(await response.text(), environment);
+  };
+  return response as unknown as T;
+}
+
+const HTTPMethods = ['GET', 'POST', 'PUT', 'DELETE', 'PATCH', 'OPTIONS', 'HEAD'] as const;
+type HTTPMethod = (typeof HTTPMethods)[number];
+
+export type ApiRequestFunction<
+  API extends { path: string; method: string; requestInput: any; requestOutput: any; response: any }
+> = <Path extends API['path'], Method extends Extract<API, { path: Path }>['method']>(
+  path: Path,
+  method: Method,
+  input: ApiInput<API, Path, Method>,
+  headers?: HeadersInit
+) => Promise<ApiResponse<API, Path, Method>>;
+
+/**
+ * @returns A function that can be used to make API requests with type safety
+ * @example const clientApiRequest = createApiRequest<ApiEndpoints>();
+ */
+export function createApiRequest<
+  API extends { path: string; method: string; requestInput: any; requestOutput: any; response: any }
+>(
+  schemas: Partial<Record<API['path'], Partial<Record<HTTPMethod, v.GenericSchema | (() => v.GenericSchema)>>>>,
+  apiUrl: string,
+  env: string
+): ApiRequestFunction<API> {
+  return async function apiRequest(path, method, input, headers) {
+    // @ts-expect-error method can be used to index schemas
+    let schema = schemas[path]?.[method];
+    if (typeof schema === 'function') {
+      schema = schema();
+    }
+
+    return _apiRequest<ApiResponse<API, typeof path, typeof method>>(
+      path as string,
+      method as 'GET' | 'POST',
+      input,
+      schema,
+      env,
+      apiUrl,
+      headers
+    );
+  };
+}

package/src/lambda/deserializer.ts

@@ -0,0 +1,11 @@
+async function deserialize(data: string, env: string | 'production'): Promise<any> {
+  if (env === 'production') {
+    const { parse: prodParse } = await import('@ungap/structured-clone/json');
+    return prodParse(data);
+  } else {
+    const cycle = await import('cycle');
+    return JSON.parse(cycle.default.retrocycle(data));
+  }
+}
+
+export { deserialize };

package/src/lambda/handlerUtils.ts

@@ -0,0 +1,47 @@
+import type { APIGatewayProxyResultV2, Context } from 'aws-lambda';
+import { stringify } from './serializer.js';
+
+/**
+ * A type for the raw proxy result - just using an object not a stirng for the body
+ */
+export type RawProxyResultV2 = {
+  statusCode?: number | undefined;
+  headers?:
+    | {
+        [header: string]: boolean | number | string;
+      }
+    | undefined;
+  body?: object | undefined;
+  isBase64Encoded?: boolean | undefined;
+  cookies?: string[] | undefined;
+};
+
+// The type of the handler returned from wrapHandler
+export type APIGatewayHandler<E> = (event: E, context: Context) => Promise<APIGatewayProxyResultV2>;
+
+// The type of the handler passed into wrapHandler
+export type RawApiGatewayHandler<E> = (event: E, context: Context) => Promise<RawProxyResultV2>;
+
+/**
+ * Wraps a handler that returns the body as an object rather than a string.
+ *
+ * This means you can achieve proper type inference on your handler and have standardised serialisation
+ *
+ * @example
+```ts
+export type AuthorizerContext = {
+  details: JWTPayload;
+} | null;
+
+export const wrapHandler = baseWrapHandler<APIGatewayProxyEventV2WithLambdaAuthorizer<AuthorizerContext>>
+
+*/
+export function wrapHandler<E>(handler: RawApiGatewayHandler<E>): APIGatewayHandler<E> {
+  return async (event: E, context: Context): Promise<APIGatewayProxyResultV2> => {
+    const result = await handler(event, context);
+    return {
+      ...result,
+      body: result.body ? await stringify(result.body) : undefined
+    };
+  };
+}

package/src/lambda/index.ts

@@ -0,0 +1 @@
+export * from './browser.js';

package/src/lambda/serializer.ts

@@ -0,0 +1,14 @@
+/**
+ * Turns object into string.
+ *
+ * Uses different methods in production and otherwise for more readable output
+ */
+export async function stringify(data: any) {
+  if (process.env.PUBLIC_ENVIRONMENT === 'production') {
+    const { stringify: prodStrigify } = await import('@ungap/structured-clone/json');
+    return prodStrigify(data);
+  } else {
+    const { decycle } = (await import('cycle')).default;
+    return JSON.stringify(decycle(data), null);
+  }
+}

package/src/ts-alias.ts

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+
+import * as fs from 'fs';
+import * as path from 'path';
+import * as chokidar from 'chokidar';
+import { replaceTscAliasPaths } from 'tsc-alias';
+import { glob } from 'glob';
+import console from 'console';
+
+// Cache for tsconfig.json files
+const tsconfigCache: Map<string, { config: any; mtime: number }> = new Map();
+
+// Parse command-line arguments
+const args = process.argv.slice(2);
+const watchMode = args.includes('-w') || args.includes('--watch');
+
+/**
+ * Find all dist folders in the project directory, excluding certain patterns.
+ */
+async function findDistFolders(baseDir: string): Promise<string[]> {
+  const ignorePatterns = [
+    '**/node_modules/**',
+    '**/\\.git/**',
+    '**/\\.vscode/**',
+    '**/\\.idea/**',
+    '**/coverage/**',
+    '**/build/**',
+    '**/cdk.out/**'
+  ];
+
+  const distFolders = await glob('**/dist', {
+    cwd: baseDir,
+    ignore: ignorePatterns,
+    absolute: true
+  });
+
+  return distFolders;
+}
+
+/**
+ * Get the tsconfig.json file for a given dist folder.
+ * This function caches the tsconfig file to avoid reading it multiple times.
+ */
+function getTsconfig(distFolder: string): any {
+  const projectRoot = path.dirname(distFolder);
+  const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+
+  try {
+    const stats = fs.statSync(tsconfigPath);
+    const mtime = stats.mtimeMs;
+
+    // Check cache
+    const cached = tsconfigCache.get(tsconfigPath);
+    if (cached && cached.mtime === mtime) {
+      return cached.config;
+    }
+
+    // Read and cache the config
+    const config = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'));
+    tsconfigCache.set(tsconfigPath, { config, mtime });
+
+    return config;
+  } catch (error) {
+    console.error(`Error reading tsconfig at ${tsconfigPath}:`, error);
+    return null;
+  }
+}
+
+/**
+ * Process the dist folder by replacing TypeScript alias paths with relative paths.
+ */
+async function processDistFolder(distFolder: string): Promise<void> {
+  const projectRoot = path.dirname(distFolder);
+  const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+
+  if (!fs.existsSync(tsconfigPath)) {
+    console.warn(`No tsconfig.json found at ${tsconfigPath}`);
+    return;
+  }
+
+  const tsconfig = getTsconfig(distFolder);
+
+  if (!tsconfig) {
+    console.warn(`Invalid tsconfig.json found for ${distFolder}`);
+    return;
+  }
+
+  try {
+    await replaceTscAliasPaths({
+      configFile: tsconfigPath,
+      outDir: distFolder
+    });
+    console.log(`Successfully processed aliases in ${distFolder}`);
+  } catch (error) {
+    console.error(`Error processing aliases in ${distFolder}:`, error);
+  }
+}
+
+/**
+ * Watch the dist folder for changes and process it when files are added or changed.
+ */
+function watchDistFolder(distFolder: string): chokidar.FSWatcher {
+  console.log(`Setting up watcher for: ${distFolder}`);
+
+  const watcher = chokidar.watch(distFolder, {
+    persistent: true,
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 300,
+      pollInterval: 100
+    }
+  });
+
+  watcher.on('add', (filePath) => {
+    if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+      console.log(`File added: ${filePath}`);
+      processDistFolder(distFolder);
+    }
+  });
+
+  watcher.on('change', (filePath) => {
+    if (filePath.endsWith('.js') || filePath.endsWith('.jsx')) {
+      console.log(`File changed: ${filePath}`);
+      processDistFolder(distFolder);
+    }
+  });
+
+  return watcher;
+}
+
+// Main function
+async function main(): Promise<void> {
+  const baseDir = process.cwd();
+  console.log(`Searching for dist folders in: ${baseDir}`);
+
+  const distFolders = await findDistFolders(baseDir);
+
+  // Process all folders initially if any exist
+  if (distFolders.length > 0) {
+    console.log(`Found ${distFolders.length} dist folders:`);
+    distFolders.forEach((folder) => console.log(` - ${folder}`));
+
+    for (const folder of distFolders) {
+      await processDistFolder(folder);
+    }
+  } else {
+    console.log('No dist folders found initially');
+  }
+
+  // Set up watchers if in watch mode
+  if (watchMode) {
+    console.log('Watch mode enabled, monitoring for changes...');
+
+    // Set up watchers for existing dist folders
+    distFolders.forEach(watchDistFolder);
+
+    // Watch for new dist folders being created
+    console.log('Watching for new dist folders...');
+    const dirWatcher = chokidar.watch(baseDir, {
+      persistent: true,
+      ignoreInitial: true,
+      depth: 5, // Adjust depth as needed for your project structure
+      ignored: [
+        '**/node_modules/**',
+        '**/\\.git/**',
+        '**/\\.vscode/**',
+        '**/\\.idea/**',
+        '**/coverage/**',
+        '**/build/**',
+        '**/cdk.out/**',
+        // Don't watch the contents of existing dist folders (they'll be watched separately)
+        ...distFolders.map((folder) => `${folder}/**`)
+      ]
+    });
+
+    // Handle directory creation events
+    dirWatcher.on('addDir', async (dirPath) => {
+      if (path.basename(dirPath) === 'dist') {
+        // Make sure it's not already being watched
+        if (!distFolders.includes(dirPath)) {
+          console.log(`New dist folder detected: ${dirPath}`);
+          distFolders.push(dirPath);
+          await processDistFolder(dirPath);
+          watchDistFolder(dirPath);
+        }
+      }
+    });
+  }
+}
+
+main().catch((error) => {
+  console.error('Error in ts-alias script:', error);
+  process.exit(1);
+});