@varlabs/create-solidstep 0.1.6 → 0.1.7

package/generate/utils/cache.ts

@@ -1,106 +0,0 @@
-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

@@ -1,25 +0,0 @@
-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

@@ -1,16 +0,0 @@
-
-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

@@ -1,27 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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/loader.ts

@@ -1,35 +0,0 @@
-import { isServer } from 'solid-js/web';
-
-type LoaderFunction<T> = (request?: Request) => Promise<T>;
-
-type LoaderOptions = {
-    type?: 'defer' | 'sequential';
-};
-
-export const defineLoader = <T>(loader: LoaderFunction<T>, options?: LoaderOptions) => {
-    if (isServer) {
-        const fn = async (request?: Request) => {
-            try {
-                const loaderData = await loader(request);
-                return {
-                    data: loaderData,
-                    type: options?.type || 'sequential',
-                };
-            } catch (error) {
-                console.error('Error in loader:', error);
-                throw error; // Re-throw to allow error handling upstream
-            }
-        };
-
-        return {
-            loader: fn,
-            options: options || {},
-        };
-    }
-
-    return null; // Return null if not on the server
-};
-
-export type LoaderDataFromFunction<T> = T extends { loader: infer L extends (...args: any) => any }
-    ? Awaited<ReturnType<T['loader']>> extends { data: infer D } ? D : never
-    : never;

package/generate/utils/redirect.ts

@@ -1,16 +0,0 @@
-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

@@ -1,272 +0,0 @@
-import { BaseFileSystemRouter } from 'vinxi/fs-router';
-import { dirname } from 'node:path';
-import { fileURLToPath } from 'node:url';
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-export class ServerRouter extends BaseFileSystemRouter {
-    toPath(src: string) {
-        src = src
-            .slice((__dirname + '/app').length);
-
-        const routePath = src
-            .replace(new RegExp(`\.(${(this.config.extensions ?? []).join('|')})$`), '')
-            .replace(/\/(page|route|layout|error|not-found|loading)$/, '');
-
-        return routePath?.length > 0 ? routePath : '/';
-    }
-
-    toRoute(filePath: string) {
-        const path = this.toPath(filePath);
-
-        if ((/route\.(js|ts)$/).test(filePath)) {
-            return {
-                type: 'route',
-                path: '/route' + path,
-                $handler: {
-                    src: filePath,
-                    pick: ['GET', 'POST', 'PUT', 'DELETE', 'PATCH'],
-                },
-            };
-        }
-
-        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,
-                $handler: {
-                    src: filePath,
-                    pick: []
-                },
-                $component: {
-                    src: filePath,
-                    pick: ['default'],
-                },
-                $loader: {
-                    src: filePath,
-                    pick: ['loader'],
-                },
-                $options: {
-                    src: filePath,
-                    pick: ['options'],
-                },
-            };
-        }
-
-        if ((/page\.(jsx|js|tsx|ts)$/).test(filePath)) {
-            return {
-                type: 'route',
-                path: '/route' + path,
-                $handler: {
-                    src: filePath,
-                    pick: []
-                },
-                $component: {
-                    src: filePath,
-                    pick: ['default'],
-                },
-                $loader: {
-                    src: filePath,
-                    pick: ['loader'],
-                },
-                $generateMeta: {
-                    src: filePath,
-                    pick: ['generateMeta'],
-                },
-                $options: {
-                    src: filePath,
-                    pick: ['options'],
-                },
-            };
-        }
-
-        if ((/layout\.(jsx|js|tsx|ts)$/).test(filePath)) {
-            return {
-                type: 'layout',
-                path: '/layout' + path,
-                $handler: {
-                    src: filePath,
-                    pick: []
-                },
-                $component: {
-                    src: filePath,
-                    pick: ['default'],
-                },
-                $loader: {
-                    src: filePath,
-                    pick: ['loader'],
-                },
-                $generateMeta: {
-                    src: filePath,
-                    pick: ['generateMeta'],
-                },
-                $options: {
-                    src: filePath,
-                    pick: ['options'],
-                },
-            };
-        }
-
-        if ((/error\.(jsx|js|tsx|ts)$/).test(filePath)) {
-            return {
-                type: 'error',
-                path: '/error' + path,
-                $handler: {
-                    src: filePath,
-                    pick: []
-                },
-                $component: {
-                    src: filePath,
-                    pick: ['default'],
-                },
-                $generateMeta: {
-                    src: filePath,
-                    pick: ['generateMeta'],
-                },
-                $options: {
-                    src: filePath,
-                    pick: ['options'],
-                },
-            };
-        }
-
-        if ((/loading\.(jsx|js|tsx|ts)$/).test(filePath)) {
-            return {
-                type: 'loading',
-                path: '/loading' + path,
-                $handler: {
-                    src: filePath,
-                    pick: []
-                },
-                $component: {
-                    src: filePath,
-                    pick: ['default'],
-                },
-                $generateMeta: {
-                    src: filePath,
-                    pick: ['generateMeta'],
-                },
-                $options: {
-                    src: filePath,
-                    pick: ['options'],
-                },
-            };
-        }
-
-        if ((/not-found\.(jsx|js|tsx|ts)$/).test(filePath) && path === '/') {
-            return {
-                type: 'not-found',
-                path: '/not-found' + path,
-                $handler: {
-                    src: filePath,
-                    pick: []
-                },
-                $component: {
-                    src: filePath,
-                    pick: ['default'],
-                },
-                $generateMeta: {
-                    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

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

package/generate/utils/types.ts

@@ -1,8 +0,0 @@
-
-export type Meta = {
-    [key: string]: {
-        type: 'link' | 'meta' | 'script' | 'style' | 'title';
-        attributes: Record<string, string>;
-        content?: string; 
-    };
-};