@tanglemedia/svelte-starter-toolbelt 1.0.0

package/README.md

@@ -0,0 +1,58 @@
+# Svelte library
+
+Everything you need to build a Svelte library, powered by [`sv`](https://npmjs.com/package/sv).
+
+Read more about creating a library [in the docs](https://svelte.dev/docs/kit/packaging).
+
+## Creating a project
+
+If you're seeing this, you've probably already done this step. Congrats!
+
+```bash
+# create a new project in the current directory
+npx sv create
+
+# create a new project in my-app
+npx sv create my-app
+```
+
+## Developing
+
+Once you've created a project and installed dependencies with `npm install` (or `pnpm install` or `yarn`), start a development server:
+
+```bash
+npm run dev
+
+# or start the server and open the app in a new browser tab
+npm run dev -- --open
+```
+
+Everything inside `src/lib` is part of your library, everything inside `src/routes` can be used as a showcase or preview app.
+
+## Building
+
+To build your library:
+
+```bash
+npm run package
+```
+
+To create a production version of your showcase app:
+
+```bash
+npm run build
+```
+
+You can preview the production build with `npm run preview`.
+
+> To deploy your app, you may need to install an [adapter](https://svelte.dev/docs/kit/adapters) for your target environment.
+
+## Publishing
+
+Go into the `package.json` and give your package the desired name through the `"name"` option. Also consider adding a `"license"` field and point it to a `LICENSE` file which you can create from a template (one popular option is the [MIT license](https://opensource.org/license/mit/)).
+
+To publish your library to [npm](https://www.npmjs.com):
+
+```bash
+npm publish
+```

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export type * from './types/index.ts';
+export * from './service/index.ts';
+export * from './utility/index.ts';

package/dist/index.js

@@ -0,0 +1,2 @@
+export * from "./service/index.js";
+export * from "./utility/index.js";

package/dist/server/index.d.ts

@@ -0,0 +1,2 @@
+export { default as apiProxyHandle } from './proxy/proxy.handle.ts';
+export type * from './proxy/proxy.handle.ts';

package/dist/server/index.js

@@ -0,0 +1 @@
+export { default as apiProxyHandle } from "./proxy/proxy.handle.js";

package/dist/server/proxy/proxy.handle.d.ts

@@ -0,0 +1,25 @@
+import { type Handle, type RequestEvent } from '@sveltejs/kit';
+export type ProxyRequestInterceptorArgs = {
+    originalRequest: RequestEvent['request'];
+    cookies: RequestEvent['cookies'];
+};
+export type ProxyRequestInterceptor = (proxyRequest: Request, opt: ProxyRequestInterceptorArgs) => Promise<Request>;
+export type ProxyResponseInterceptorArgs = {
+    originalRequest: RequestEvent['request'];
+    proxyRequest: Request;
+};
+export type ProxyResponseInterceptor = (proxyRequest: Response, opt: ProxyResponseInterceptorArgs) => Promise<Response>;
+export type ProxyOptions = {
+    proxyPath: string;
+    proxyEndpoint: string;
+    requestInterceptors?: ProxyRequestInterceptor[];
+    responseInterceptors?: ProxyResponseInterceptor[];
+    setResponseHeaders?: Record<string, string> | ((request: Request, response: Response) => Record<string, string>);
+};
+/**
+ * Taken from https://sami.website/blog/sveltekit-api-reverse-proxy
+ * @param param0
+ * @returns
+ */
+declare const apiProxyHandle: ({ proxyPath, proxyEndpoint, requestInterceptors, responseInterceptors, setResponseHeaders }: ProxyOptions) => Handle;
+export default apiProxyHandle;

package/dist/server/proxy/proxy.handle.js

@@ -0,0 +1,134 @@
+import { dev } from '$app/environment';
+import { error } from '@sveltejs/kit';
+if (dev) {
+    process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0';
+}
+/**
+ * Taken from https://sami.website/blog/sveltekit-api-reverse-proxy
+ * @param param0
+ * @returns
+ */
+const apiProxyHandle = ({ proxyPath, proxyEndpoint, requestInterceptors = [], responseInterceptors = [], setResponseHeaders }) => async ({ event, resolve }) => {
+    const { url, request, cookies } = event;
+    if (!url.pathname.startsWith(proxyPath)) {
+        return resolve(event);
+    }
+    const getProxyHeaders = typeof setResponseHeaders !== 'function'
+        ? (() => setResponseHeaders || {})
+        : setResponseHeaders;
+    // console.log(
+    //   `[PROXY] Begin ${request.method} proxy request from ${proxyPath} to ${proxyEndpoint}`
+    // );
+    // reject requests that don't come from the webapp, to avoid your proxy being abused.
+    // if (!origin || new URL(origin).origin !== url.origin) {
+    //   throw error(403, "Request Forbidden.");
+    // }
+    const strippedPath = url.pathname.substring(proxyPath.length);
+    // build the new URL path with your API base URL, the stripped path and the query string
+    const urlPath = `${proxyEndpoint}${strippedPath}${event.url.search}`;
+    const proxiedUrl = new URL(urlPath);
+    // only forward these headers
+    // todo: Determine what other headers we shoud forward
+    const forwardReqHeaders = ['Authorization', 'Content-Type', 'Accept'].reduce((acc, k) => {
+        const header = event.request.headers.get(k);
+        if (header) {
+            // console.log(k, header);
+            acc.append(k, header);
+        }
+        return acc;
+    }, new Headers());
+    const proxyOpt = {
+        // propagate the request method and body
+        body: event.request.body,
+        method: event.request.method,
+        headers: forwardReqHeaders,
+        // headers: event.request.headers,
+        // headers: {
+        //   cookie: event.request.headers.get('cookie') ?? ''
+        // },
+        credentials: 'include'
+    };
+    if (event.request.method === 'POST' ||
+        event.request.method === 'PATCH' ||
+        event.request.method === 'DELETE' ||
+        event.request.method === 'PUT') {
+        proxyOpt.duplex = 'half';
+        // // reading the body (debug)
+        // const reader = event.request.body!.getReader()
+        // let html = '', x = true;
+        // while (x) {
+        //   const { value, done } = await reader.read()
+        //   if (value) {
+        //     html += new TextDecoder().decode(value)
+        //   }
+        //   if (done) {
+        //     x = false;
+        //   }
+        // }
+        // console.log('READING BODY', html)
+    }
+    const proxyReq = new Request(proxiedUrl, proxyOpt);
+    try {
+        let req = proxyReq;
+        for (let i = 0; i < requestInterceptors.length; i++) {
+            const interceptor = requestInterceptors[i];
+            req = await interceptor(req, {
+                originalRequest: request,
+                cookies
+            });
+        }
+        req.headers.set('Connection', 'close');
+        // console.log('BEFOIRE FETCH', proxiedUrl, proxyOpt, req.headers)
+        let response = await event.fetch(req);
+        // console.log(
+        //   `[PROXY] Response from proxy ${req.url.toString()}. ${response.status} ${response.statusText}`
+        // );
+        for (let i = 0; i < responseInterceptors.length; i++) {
+            const interceptor = responseInterceptors[i];
+            response = await interceptor(response, {
+                originalRequest: request,
+                proxyRequest: req
+            });
+        }
+        // todo: check for the cookie and pass that down
+        const passHeaders = ['cache-control', 'vary', 'content-type'].reduce((acc, k) => {
+            const header = response.headers.get(k);
+            if (header) {
+                acc.append(k, header);
+            }
+            return acc;
+        }, new Headers());
+        const contentType = response.headers.get('content-type');
+        const responseOptions = {
+            headers: passHeaders,
+            status: response.status,
+            statusText: response.statusText
+        };
+        // apply overwritten header values to the proxied response
+        const proxyHeaders = getProxyHeaders(request, response);
+        for (const k in proxyHeaders) {
+            const header = proxyHeaders[k];
+            responseOptions.headers.set(k, header);
+        }
+        if (response.status === 204) {
+            return Response.json({}, {
+                ...responseOptions,
+                status: 200
+            });
+        }
+        // console.log('test', contentType?.startsWith('text/'))
+        if (contentType?.startsWith('text/')) {
+            return new Response(await response.text(), responseOptions);
+        }
+        const data = await response.json();
+        return Response.json(data, responseOptions);
+    }
+    catch (e) {
+        console.error(`Could not proxy API request to ${proxiedUrl.toString()}`);
+        console.log(e);
+        error(500, e instanceof Error ? { message: e.message } : { message: 'Unknown error has occurred' });
+    }
+    // should never reach here
+    return resolve(event);
+};
+export default apiProxyHandle;

package/dist/service/index.d.ts

@@ -0,0 +1,2 @@
+export * from './provider/create-directus-service.provider.ts';
+export * from './service.factory.ts';

package/dist/service/index.js

@@ -0,0 +1,2 @@
+export * from "./provider/create-directus-service.provider.js";
+export * from "./service.factory.js";