@varlabs/create-solidstep 0.1.2 → 0.1.4

package/generate/tsconfig.json

@@ -0,0 +1,16 @@
+{
+	"compilerOptions": {
+		"target": "ESNext",
+		"module": "ESNext",
+		"moduleResolution": "Bundler",
+		"allowSyntheticDefaultImports": true,
+		"esModuleInterop": true,
+		"jsx": "preserve",
+		"jsxImportSource": "solid-js",
+		"allowJs": true,
+		"checkJs": true,
+		"noEmit": true,
+		"types": ["vinxi/client"],
+		"isolatedModules": true
+	}
+}

package/generate/utils/cache.ts

@@ -0,0 +1,106 @@
+type CacheValue<T = any> = {
+    key: string
+    value: T
+    expiresAt: number | null
+    prev?: CacheValue<T>
+    next?: CacheValue<T>
+};
+
+const MAX_CACHE_ENTRIES = 1000;
+
+const cacheMap = new Map<string, CacheValue>();
+let head: CacheValue | undefined;
+let tail: CacheValue | undefined;
+
+const moveToFront = <T>(node: CacheValue<T>) => {
+    if (node === head) return;
+
+    // Detach
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+
+    if (node === tail) tail = node.prev;
+
+    // Insert at head
+    node.prev = undefined;
+    node.next = head;
+    if (head) head.prev = node;
+    head = node;
+
+    if (!tail) tail = node;
+};
+
+const removeTail = <T>() => {
+    if (!tail) return;
+    cacheMap.delete(tail.key);
+
+    if (tail.prev) {
+        tail.prev.next = undefined;
+        tail = tail.prev;
+    } else {
+        // Only one node
+        head = tail = undefined;
+    }
+};
+
+export const getCache = <T>(key: string): T | null => {
+    const entry = cacheMap.get(key);
+    if (!entry) return null;
+
+    if (entry.expiresAt && entry.expiresAt < Date.now()) {
+        cacheMap.delete(key);
+        if (entry.prev) entry.prev.next = entry.next;
+        if (entry.next) entry.next.prev = entry.prev;
+        if (entry === head) head = entry.next;
+        if (entry === tail) tail = entry.prev;
+        return null;
+    }
+
+    moveToFront(entry);
+    return entry.value;
+};
+
+export const setCache = <T>(key: string, value: T, ttlMs?: number) => {
+    if (cacheMap.has(key)) {
+        const node = cacheMap.get(key)!;
+        node.value = value;
+        node.expiresAt = ttlMs ? Date.now() + ttlMs : null;
+        moveToFront(node);
+        return;
+    }
+
+    const newNode: CacheValue<T> = {
+        key,
+        value,
+        expiresAt: ttlMs ? Date.now() + ttlMs : null
+    };
+
+    newNode.next = head;
+    if (head) head.prev = newNode;
+    head = newNode;
+
+    if (!tail) tail = newNode;
+
+    cacheMap.set(key, newNode);
+
+    if (cacheMap.size > MAX_CACHE_ENTRIES) {
+        removeTail();
+    }
+};
+
+export const invalidateCache = (key: string) => {
+    const node = cacheMap.get(key);
+    if (!node) return;
+
+    if (node.prev) node.prev.next = node.next;
+    if (node.next) node.next.prev = node.prev;
+    if (node === head) head = node.next;
+    if (node === tail) tail = node.prev;
+
+    cacheMap.delete(key);
+};
+
+export const clearAllCache = () => {
+    cacheMap.clear();
+    head = tail = undefined;
+};

package/generate/utils/cookies.ts

@@ -0,0 +1,25 @@
+import { 
+    setCookie as baseSetCookie, 
+    getCookie as baseGetCookie,
+    deleteCookie as baseDeleteCookie,
+    getEvent 
+} from 'vinxi/http';
+
+export const getCookie = (key: string): string | undefined => {
+    const event = getEvent();
+    return baseGetCookie(event, key);
+};
+
+export const setCookie = (
+    key: string, 
+    value: string,
+    options?: Parameters<typeof baseSetCookie>[2]
+) => {
+    const event = getEvent();
+    return baseSetCookie(event, key, value, options);
+}
+
+export const deleteCookie = (key: string) => {
+    const event = getEvent();
+    return baseDeleteCookie(event, key);
+};

package/generate/utils/cors.ts

@@ -0,0 +1,16 @@
+
+export const cors = (trustedOrigins: string[]) => (origin: string, isPreflight: boolean) => {
+    if (trustedOrigins.includes(origin)) {
+        if (isPreflight) {
+            return {
+                'Access-Control-Allow-Origin': origin,
+                'Access-Control-Allow-Methods': 'GET, POST, PUT, PATCH, DELETE, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Authorization',
+            };
+        }
+        return {
+            'Access-Control-Allow-Origin': origin,
+        };
+    }
+    return {};
+}

package/generate/utils/csp.ts

@@ -0,0 +1,27 @@
+export const cspNonce = (nonce: string) => `
+    default-src 'self';
+    font-src 'self' https://fonts.gstatic.com;
+    object-src 'none';
+    base-uri 'none';
+    frame-ancestors 'none';
+    form-action 'self';
+    style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
+    style-src-elem 'self' 'unsafe-inline' https://fonts.googleapis.com;
+    script-src 'nonce-${nonce}' 'strict-dynamic' 'unsafe-eval';
+    connect-src 'self' ws:;
+    img-src 'self' data:;
+`.replace(/\s+/g, ' ');
+
+export const csp = `
+    default-src 'self';
+    font-src 'self' https://fonts.gstatic.com;
+    object-src 'none';
+    base-uri 'none';
+    frame-ancestors 'none';
+    form-action 'self';
+    style-src 'self' 'unsafe-inline' https://fonts.googleapis.com;
+    style-src-elem 'self' 'unsafe-inline' https://fonts.googleapis.com;
+    script-src 'self' 'unsafe-inline' 'unsafe-eval';
+    connect-src 'self' ws:;
+    img-src 'self' data:;
+`.replace(/\s+/g, ' ');

package/generate/utils/csrf.ts

@@ -0,0 +1,62 @@
+const SAFE_METHODS = ['GET', 'OPTIONS', 'HEAD', 'TRACE'];
+
+export const csrf = (trustedOrigins: string[]) => 
+    (
+        requestMethod: string,
+        requestUrl: URL, 
+        origin?: string, 
+        referer?: string
+    ) => {
+        // Check if the request method is safe
+        if (!SAFE_METHODS.includes(requestMethod)) {
+            // If we have an Origin header, check it against our allowlist.
+            if (origin) {
+                const parsedOrigin = new URL(origin);
+                if (
+                    parsedOrigin.origin !== requestUrl.origin &&
+                    !trustedOrigins.includes(parsedOrigin.host)
+                ) {
+                    return {
+                        success: false,
+                        message: 'Invalid origin',
+                    };
+                }
+            }
+
+            // If we are serving via TLS and have no Origin header, prevent against
+            // CSRF via HTTP man-in-the-middle attacks by enforcing strict Referer
+            // origin checks.
+            if (!origin && requestUrl.protocol === 'https:') {
+                if (!referer) {
+                    return {
+                        success: false,
+                        message: 'referer not supplied',
+                    };
+                }
+
+                const parsedReferer = new URL(referer);
+
+                if (parsedReferer.protocol !== 'https:') {
+                    return {
+                        success: false,
+                        message: 'Invalid referer',
+                    };
+                }
+
+                if (
+                    parsedReferer.host !== requestUrl.host &&
+                    !trustedOrigins.includes(parsedReferer.host)
+                ) {
+                    return {
+                        success: false,
+                        message: 'Invalid referer',
+                    };
+                }
+            }
+        }
+
+        return {
+            success: true,
+            message: 'CSRF check passed',
+        };
+    };

package/generate/utils/redirect.ts

@@ -0,0 +1,16 @@
+import { isServer } from 'solid-js/web';
+
+export class RedirectError extends Error {
+    constructor(message: string) {
+        super(message);
+        this.name = 'RedirectError';
+    }
+}
+
+export const redirect = (url: string) => {
+    if (isServer) {
+        throw new RedirectError(url);
+    } else {
+        window.location.href = url;
+    }
+};

package/generate/utils/router.ts

@@ -4,7 +4,7 @@ import { fileURLToPath } from 'node:url';
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
-export class Router extends BaseFileSystemRouter {
+export class ServerRouter extends BaseFileSystemRouter {
     toPath(src: string) {
         src = src
             .slice((__dirname + '/app').length);
@@ -39,6 +39,10 @@ export class Router extends BaseFileSystemRouter {
                 type: 'group',
                 parent: parent,
                 path: '/group' + path,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
                 $component: {
                     src: filePath,
                     pick: ['default'],
@@ -47,6 +51,10 @@ export class Router extends BaseFileSystemRouter {
                     src: filePath,
                     pick: ['loader'],
                 },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
             };
         }
 
@@ -54,6 +62,10 @@ export class Router extends BaseFileSystemRouter {
             return {
                 type: 'route',
                 path: '/route' + path,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
                 $component: {
                     src: filePath,
                     pick: ['default'],
@@ -66,6 +78,10 @@ export class Router extends BaseFileSystemRouter {
                     src: filePath,
                     pick: ['generateMeta'],
                 },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
             };
         }
 
@@ -73,6 +89,10 @@ export class Router extends BaseFileSystemRouter {
             return {
                 type: 'layout',
                 path: '/layout' + path,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
                 $component: {
                     src: filePath,
                     pick: ['default'],
@@ -85,6 +105,10 @@ export class Router extends BaseFileSystemRouter {
                     src: filePath,
                     pick: ['generateMeta'],
                 },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
             };
         }
 
@@ -92,6 +116,10 @@ export class Router extends BaseFileSystemRouter {
             return {
                 type: 'error',
                 path: '/error' + path,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
                 $component: {
                     src: filePath,
                     pick: ['default'],
@@ -100,6 +128,10 @@ export class Router extends BaseFileSystemRouter {
                     src: filePath,
                     pick: ['generateMeta'],
                 },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
             };
         }
 
@@ -107,6 +139,10 @@ export class Router extends BaseFileSystemRouter {
             return {
                 type: 'loading',
                 path: '/loading' + path,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
                 $component: {
                     src: filePath,
                     pick: ['default'],
@@ -115,6 +151,10 @@ export class Router extends BaseFileSystemRouter {
                     src: filePath,
                     pick: ['generateMeta'],
                 },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
             };
         }
 
@@ -122,6 +162,10 @@ export class Router extends BaseFileSystemRouter {
             return {
                 type: 'not-found',
                 path: '/not-found' + path,
+                $handler: {
+                    src: filePath,
+                    pick: []
+                },
                 $component: {
                     src: filePath,
                     pick: ['default'],
@@ -130,6 +174,98 @@ export class Router extends BaseFileSystemRouter {
                     src: filePath,
                     pick: ['generateMeta'],
                 },
+                $options: {
+                    src: filePath,
+                    pick: ['options'],
+                },
+            };
+        }
+    }
+}
+
+export class ClientRouter extends BaseFileSystemRouter {
+    toPath(src: string) {
+        src = src
+            .slice((__dirname + '/app').length);
+
+        const routePath = src
+            .replace(new RegExp(`\.(${(this.config.extensions ?? []).join('|')})$`), '')
+            .replace(/\/(page|layout|error|not-found|loading)$/, '');
+
+        return routePath?.length > 0 ? routePath : '/';
+    }
+
+    toRoute(filePath: string) {
+        const path = this.toPath(filePath);
+
+        const scopedPackageMatch = path.match(/@[^]+/g);
+        if (scopedPackageMatch) {
+            // Remove the scoped package part
+            const scopedPackage = scopedPackageMatch[0];
+            const parent = path.replace('/' + scopedPackage, '');
+            return {
+                type: 'group',
+                parent: parent,
+                path: '/group' + path,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+
+        if ((/page\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'route',
+                path: '/route' + path,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+
+        if ((/layout\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'layout',
+                path: '/layout' + path,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+
+        if ((/error\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'error',
+                path: '/error' + path,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+
+        if ((/loading\.(jsx|js|tsx|ts)$/).test(filePath)) {
+            return {
+                type: 'loading',
+                path: '/loading' + path,
+                $component: {
+                    src: filePath,
+                    pick: ['default', '$css'],
+                },
+            };
+        }
+
+        if ((/not-found\.(jsx|js|tsx|ts)$/).test(filePath) && path === '/') {
+            return {
+                type: 'not-found',
+                path: '/not-found' + path,
+                $component: {
+                    src: filePath,
+                    pick: ['default'],
+                },
             };
         }
     }

package/generate/utils/server-only.ts

@@ -0,0 +1,5 @@
+import { isServer } from 'solid-js/web';
+
+if (!isServer) {
+    throw new Error('This module is only available on the server side.');
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@varlabs/create-solidstep",
-    "version": "0.1.2",
+    "version": "0.1.4",
     "description": "Next Step SolidJS CLI for building web applications.",
     "type": "module",
     "author": "HamzaKV <hamzakv333@gmail.com>",