@zikojs/server 0.1.0 → 0.3.0

package/package.json

@@ -1,63 +1,47 @@
-{
-  "name": "@zikojs/server",
-  "version": "0.1.0",
-  "description": "server side rendering in zikojs with file-based-routing and client side hydration",
-  "type": "module",
-  "source": "src/index.js",
-  "files": [
-    "src",
-    "types",
-    "dist",
-    "LICENCE"
-  ],
-  "exports": {
-    ".": "./src/index.js",
-    "./*": "./src/*/index.js"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "keywords": [
-    "ziko",
-    "zikojs",
-    "ssr",
-    "ssg",
-    "rendering",
-    "hydration",
-    "server",
-    "middlewares"
-  ],
-  "scripts": {
-    "dev": "rollup -c rollup.config.js -w",
-    "build": "rollup -c rollup.config.js",
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "start-demo": "cd demo && npm run dev "
-  },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/zakarialaoui10/ziko-server.git"
-  },
-  "author": "zakaria elalaoui",
-  "license": "MIT",
-  "bugs": {
-    "url": "https://github.com/zakarialaoui10/ziko-server/issues"
-  },
-  "homepage": "https://github.com/zakarialaoui10/ziko-server#readme",
-  "devDependencies": {
-    "@rollup/plugin-commonjs": "^29.0.3",
-    "@rollup/plugin-node-resolve": "^16.0.3",
-    "@rollup/plugin-terser": "^1.0.0",
-    "rollup": "^4.62.4"
-  },
-  "dependencies": {
-    "compression": "^1.8.1",
-    "cross-env": "^10.1.0",
-    "express": "^5.2.1",
-    "extendom": "^0.0.0",
-    "fast-glob": "^3.3.3",
-    "jsdom": "^30.0.1",
-    "sirv": "^3.0.2",
-    "vite": "^8.2.1",
-    "ziko": "^1.8.0"
-  }
-}
+{
+  "name": "@zikojs/server",
+  "version": "0.3.0",
+  "description": "",
+  "main": "index.js",
+  "keywords": [
+    "zikojs",
+    "server",
+    "express"
+  ],
+  "homepage": "https://github.com/zikojs/ziko#readme",
+  "bugs": {
+    "url": "https://github.com/zikojs/ziko/issues"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/zikojs/ziko.git",
+    "directory": "packages/adapters/express"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "exports": {
+    ".": {
+      "import": "./src/index.js"
+    },
+    "./*": {
+      "import": "./src/*/index.js"
+    }
+  },
+  "author": "zakaria elalaoui",
+  "license": "MIT",
+  "type": "module",
+  "dependencies": {
+    "@zikojs/server-express": "0.1.0",
+    "@zikojs/server-http": "0.1.0",
+    "compression": "^1.8.1",
+    "express": "^5.2.1",
+    "fast-glob": "^3.3.3",
+    "sirv": "^3.0.2",
+    "vite": "^8.2.2",
+    "ziko": "^2.0.0-beta.7"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  }
+}

package/src/index.js

@@ -1,4 +1 @@
-export {EntryClient} from "./entry-client/index.js";
-export {EntryServer} from "./entry-server/index.js";
-export {createServer} from "./server/index.js";
-export * from './prerender/index.js'
+export * from './server/index.js'

package/src/middlewares/index.js

@@ -0,0 +1,2 @@
+export * from './setupEnvironmentMiddleware.js'
+export * from './trailingSlashMiddleware.js'

package/src/middlewares/setupEnvironmentMiddleware.js

@@ -0,0 +1,37 @@
+const isProduction = process.env.NODE_ENV === 'production'
+/**
+ * Sets up environment-specific middleware.
+ */
+export async function setupEnvironmentMiddleware({ adapterInstance, rootDir, urlBase, clientDistPath }) {
+  if (process.env.NODE_ENV !== 'production') {
+    const { createServer: createViteServer } = await import('vite')
+    const vite = await createViteServer({
+      root: rootDir,
+      server: { middlewareMode: true },
+      appType: 'custom',
+      base: urlBase,
+    })
+
+    // Vite handles all dev transformation and /@vite/client asset requests
+    adapterInstance.use(vite.middlewares)
+    return vite
+  }
+
+  // PRODUCTION MODE: Serve static client assets from dist/client
+  const compression = (await import('compression')).default
+  const sirv = (await import('sirv')).default
+
+  adapterInstance.use(compression())
+
+  // Serve all built assets (JS, CSS, images, favicon) from dist/client
+  adapterInstance.usePath(
+    urlBase,
+    sirv(clientDistPath, {
+      dev: false,
+      single: false, // Allows static assets to return 404 rather than falling back to HTML
+      extensions: []
+    })
+  )
+
+  return undefined
+}

package/src/middlewares/trailingSlashMiddleware.js

@@ -0,0 +1,103 @@
+const isProduction = process.env.NODE_ENV === 'production'
+
+/**
+ * Handles trailing slashes based on the specified behavior strategy.
+ *
+ * @param {'ignore' | 'always' | 'never'} behavior
+ * @param {import('http').IncomingMessage} req
+ * @param {import('http').ServerResponse} res
+ * @param {Function} next
+ */
+export function trailingSlashMiddleware(behavior, req, res, next) {
+  // 1. Skip middleware if behavior is 'ignore'
+  if (!behavior || behavior === 'ignore') {
+    return next()
+  }
+
+  const rawUrl = req.originalUrl || req.url
+  const [pathname, search] = rawUrl.split('?')
+  const queryString = search ? `?${search}` : ''
+
+  // Don't redirect the root path '/' or URLs pointing to static files (e.g. assets)
+  const isRoot = pathname === '/'
+  const isFile = /\.[a-zA-Z0-9]+$/.test(pathname)
+
+  if (isRoot || isFile) {
+    return next()
+  }
+
+  const hasTrailingSlash = pathname.endsWith('/')
+
+  // ---------------------------------------------------------------------------
+  // Case A: Behavior 'never' -> Require NO trailing slash (e.g. /about)
+  // ---------------------------------------------------------------------------
+  if (behavior === 'never' && hasTrailingSlash) {
+    const targetPath = pathname.replace(/\/+$/, '')
+    const targetUrl = targetPath + queryString
+
+    if (!isProduction) {
+      const warningHtml = `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Trailing Slash Warning</title>
+            <style>
+              body { font-family: system-ui, sans-serif; padding: 2rem; background: #1a1a1a; color: #fff; line-height: 1.6; }
+              .card { background: #2a2a2a; border-left: 4px solid #f39c12; padding: 1.5rem; border-radius: 6px; max-width: 600px; }
+              code { background: #333; padding: 0.2rem 0.4rem; border-radius: 4px; color: #e74c3c; }
+              a { color: #3498db; }
+            </style>
+          </head>
+          <body>
+            <div class="card">
+              <h2>[ZikoJS Dev Warning] Trailing Slash Mismatch</h2>
+              <p>Requested URL: <code>${rawUrl}</code></p>
+              <p>Your trailing slash strategy is configured to <strong>'never'</strong>, but this request includes a trailing slash.</p>
+              <p>In production, this request will automatically redirect (301) to: <a href="${targetUrl}"><code>${targetUrl}</code></a></p>
+            </div>
+          </body>
+        </html>
+      `
+      return res.status(200).set({ 'Content-Type': 'text/html' }).send(warningHtml)
+    }
+
+    return res.status(301).set({ Location: targetUrl }).send()
+  }
+
+  // ---------------------------------------------------------------------------
+  // Case B: Behavior 'always' -> Require trailing slash (e.g. /about/)
+  // ---------------------------------------------------------------------------
+  if (behavior === 'always' && !hasTrailingSlash) {
+    const targetUrl = `${pathname}/${queryString}`
+
+    if (!isProduction) {
+      const warningHtml = `
+        <!DOCTYPE html>
+        <html>
+          <head>
+            <title>Trailing Slash Warning</title>
+            <style>
+              body { font-family: system-ui, sans-serif; padding: 2rem; background: #1a1a1a; color: #fff; line-height: 1.6; }
+              .card { background: #2a2a2a; border-left: 4px solid #f39c12; padding: 1.5rem; border-radius: 6px; max-width: 600px; }
+              code { background: #333; padding: 0.2rem 0.4rem; border-radius: 4px; color: #e74c3c; }
+              a { color: #3498db; }
+            </style>
+          </head>
+          <body>
+            <div class="card">
+              <h2>[ZikoJS Dev Warning] Trailing Slash Mismatch</h2>
+              <p>Requested URL: <code>${rawUrl}</code></p>
+              <p>Your trailing slash strategy is configured to <strong>'always'</strong>, but this request is missing a trailing slash.</p>
+              <p>In production, this request will automatically redirect (301) to: <a href="${targetUrl}"><code>${targetUrl}</code></a></p>
+            </div>
+          </body>
+        </html>
+      `
+      return res.status(200).set({ 'Content-Type': 'text/html' }).send(warningHtml)
+    }
+
+    return res.status(301).set({ Location: targetUrl }).send()
+  }
+
+  next()
+}

package/src/server/index.js

@@ -1,105 +1,87 @@
-import express from "express";
-import { readFile } from "node:fs/promises";
-import path, { join } from "node:path";
-import { pathToFileURL } from "node:url";
-import { dev_server } from "./dev-server.js";
-import { API_HANDLER } from "./api-handler.js";
-import { 
-  importMiddlewares,
-  importPrerenderedRoutes,
-} from '../server-only-utils/index.js'
-
-import { setup_ziko_folder } from "../setup/setup-ziko-folder.js";
-import { SetupMiddleware } from './setup-middleware.js'
-
-export async function createServer({ baseDir = process.cwd(), port = process.env.PORT || 5173 } = {}){
-  await setup_ziko_folder(join(baseDir, './.ziko-experimental'))
-  const isProduction = process.env.NODE_ENV === "production";
-  const base = process.env.BASE || "/";
-  const HTML_TEMPLATE = isProduction ? await readFile(join(baseDir, "./dist/.client/.ziko/index.html"), "utf-8") : "";
-  const app = express();
-
-  const Middlewares = await importMiddlewares()
-  app.use(Middlewares.logger)
-  app.use(SetupMiddleware)
-
-  let vite;
-  if (!isProduction) vite = await dev_server(app, base)
-  else {
-    const compression = (await import("compression")).default;
-    const sirv = (await import("sirv")).default;
-    app.use(compression());
-    app.use(
-      base,
-      sirv(join(baseDir, "./dist/.client"), { extensions: [] }),
-    );
-  }
-
-  // Serve HTML
-  app.use('/.client', express.static(path.join(process.cwd(), 'dist/.client')))
-  // app.use(express.static('public'))
-    
-  if(isProduction){
-      const PRERENDERED_ROUTES = await importPrerenderedRoutes()
-      for(let i=0; i<PRERENDERED_ROUTES.length; i++){
-        app.get(PRERENDERED_ROUTES[i], (req, res)=>{
-          res.sendFile(path.join(process.cwd(), `dist/${PRERENDERED_ROUTES[i]}/index.html`))
-        })
-      }
-  }
-
-
-  app.get('/--ziko--', (req, res)=>{
-    res.json(globalThis.Ziko)
-  })
-
-  app.use(async (req, res) => {
-    try {
-      const url = req.originalUrl.replace(base, "");
-      let template;
-      let render;
-      if (!isProduction) {
-        template = await readFile(join(baseDir, "./.ziko/index.html"), "utf-8");
-        template = await vite.transformIndexHtml(url, template);
-        render = (await vite.ssrLoadModule("/.ziko/entry-server.js")).default;
-      } 
-      else {
-        template = HTML_TEMPLATE;
-        const ENTRY_SERVER_PATH = pathToFileURL(join(baseDir, "./dist/.server/entry-server.js")).href;
-        render = (await import(/* @vite-ignore */ENTRY_SERVER_PATH)).default;
-      }
-      const rendered = await render(url, req);
-      const page = await rendered(url, req);
-      if(page.GET) return await API_HANDLER(page.GET, req, res)
-      if(page.POST) return await API_HANDLER(page.POST, req, res)
-      if(page.PUT) return await API_HANDLER(page.PUT, req, res)
-      if(page.DELETE) return await API_HANDLER(page.DELETE, req, res)
-      if(page.PATCH) return await API_HANDLER(page.PATCH, req, res)
-        
-      const html = template
-        .replace(
-          '<!--app-session-data-->',
-          `<script type='application/json' id='ziko-data'>
-${JSON.stringify(Ziko, null, 2)}
-          </script>
-          `
-        )
-        // .replace(`<!--app-head-->`, page.head ?? "")
-        .replace(`<!--app-html-->`, page.ui ?? "")
-        
-      res.status(200).set({ "Content-Type": "text/html" }).send(html);
-    } 
-    catch (e) {
-      vite?.ssrFixStacktrace(e);
-      res.status(500).end(e.stack);
-    }
-  });
-
-  app.listen(port, () => {
-    console.log(`Server started at http://localhost:${port}`);
-  });
-
-  return app;
-}
-
-
+import fs from 'node:fs/promises'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url' // <--- 1. Import pathToFileURL
+import { httpAdapter } from '@zikojs/server-http'
+import { expressAdapter } from '@zikojs/server-express'
+import express from 'express'
+import { 
+  setupEnvironmentMiddleware,
+  trailingSlashMiddleware
+} from '../middlewares/index.js'
+
+const isProduction = process.env.NODE_ENV === 'production'
+
+export async function createServer({
+  adapter = expressAdapter,
+  port = process.env.PORT || 5173,
+  base = process.env.BASE || '/',
+  trailingSlash = 'never',
+  cwd = process.cwd()
+} = {}) {
+  const rootDir = cwd
+
+  // 1. Resolve adapter
+  const adapterInstance = typeof adapter === 'function' ? adapter() : adapter
+
+  // 2. Normalize Base URL
+  const normalizedBase = base.startsWith('/') ? base : `/${base}`
+  const urlBase = normalizedBase.endsWith('/') ? normalizedBase : `${normalizedBase}/`
+
+  // 3. Resolve absolute filesystem paths relative to rootDir
+  const clientDistPath = path.resolve(rootDir, './dist/client')
+  const serverDistPath = path.resolve(rootDir, './dist/server/entry-server.js')
+  const indexHtmlPath = path.resolve(rootDir, './index.html')
+
+  // 4. Attach Trailing Slash Middleware
+  adapterInstance.use((req, res, next) => {
+    trailingSlashMiddleware(trailingSlash, req, res, next)
+  })
+
+  // 5. Setup environment middleware
+  const vite = await setupEnvironmentMiddleware({
+    adapterInstance,
+    rootDir,
+    urlBase,
+    clientDistPath
+  })
+
+  // Cached production assets
+  const templateHtml = isProduction
+    ? await fs.readFile(path.join(clientDistPath, 'index.html'), 'utf-8')
+    : ''
+
+  // 6. SSR Route Handler
+  adapterInstance.handleRoute('*', async (req, res) => {
+    try {
+      const url = req.originalUrl.replace(urlBase, '')
+
+      let template
+      let render
+      if (!isProduction) {
+        template = await fs.readFile(indexHtmlPath, 'utf-8')
+        template = await vite.transformIndexHtml(url, template)
+        render = (await vite.ssrLoadModule('/.ziko/entry-server.js')).render
+      } else {
+        template = templateHtml
+        // 2. Wrap serverDistPath with pathToFileURL().href for Windows ESM compatibility
+        render = (await import(pathToFileURL(serverDistPath).href)).render
+      }
+
+      const rendered = await render(url)
+
+      const html = template
+        .replace(`<!--app-head-->`, rendered.head ?? '')
+        .replace(`<!--app-html-->`, rendered.html ?? '')
+
+      res.status(200).set({ 'Content-Type': 'text/html' }).send(html)
+    } catch (e) {
+      vite?.ssrFixStacktrace(e)
+      console.error(e.stack)
+      res.status(500).send(e.stack)
+    }
+  })
+
+  return adapterInstance.listen(port, () => {
+    console.log(`Server started at http://localhost:${port}${urlBase}`)
+  })
+}

package/src/server-only-utils/globImports.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Server-side replica of Vite's `import.meta.glob()`.
+ *
+ * @param pattern - Fast-glob pattern(s).
+ * @param options - Configuration options.
+ * @param options.cwd - Working directory. Defaults to `process.cwd()`.
+ * @param options.eager - Return evaluated exports instead of functions.
+ * @param options.keyType - Key formatting style.
+ *
+ * @returns A promise resolving to a record of module loaders or evaluated
+ * module exports.
+ */
+export function globImports<T = any>(
+  pattern?: string | string[],
+  options?: GlobImportsOptions
+): Promise<GlobImportsResult<T>>;
+
+/**
+ * Options for `globImports()`.
+ */
+export interface GlobImportsOptions {
+  /**
+   * Working directory used as the base for resolving glob patterns.
+   *
+   * @default process.cwd()
+   */
+  cwd?: string;
+
+  /**
+   * Whether to eagerly import and evaluate all matched modules.
+   *
+   * When `false`, each value is a function that lazily imports the module.
+   *
+   * @default false
+   */
+  eager?: boolean;
+
+  /**
+   * Key formatting style for matched module paths.
+   *
+   * - `relative` - Relative paths, matching Vite's default behavior.
+   * - `absolute` - Absolute filesystem paths.
+   * - `fileUrl` - `file://` URLs.
+   *
+   * @default 'relative'
+   */
+  keyType?: GlobImportsKeyType;
+}
+
+/**
+ * Supported key formatting styles for `globImports()`.
+ */
+export type GlobImportsKeyType =
+  | 'relative'
+  | 'absolute'
+  | 'fileUrl';
+
+/**
+ * A lazy module importer returned by `globImports()`
+ * when `eager` is `false`.
+ */
+export type GlobImportLoader<T = any> = () => Promise<T>;
+
+/**
+ * Result returned by `globImports()`.
+ *
+ * When `eager` is `false`, values are lazy module loaders.
+ * When `eager` is `true`, values are the evaluated module exports.
+ */
+export type GlobImportsResult<T = any> = Record<
+  string,
+  GlobImportLoader<T> | T
+>;

package/src/server-only-utils/globImports.js

@@ -0,0 +1,50 @@
+import fg from 'fast-glob'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+
+/**
+ * Server-side replica of Vite's import.meta.glob().
+ *
+ * @param {string | string[]} pattern - Fast-glob pattern(s)
+ * @param {Object} options
+ * @param {string} [options.cwd=process.cwd()] - Working directory
+ * @param {boolean} [options.eager=false] - Return evaluated exports instead of functions
+ * @param {'relative' | 'absolute' | 'fileUrl'} [options.keyType='relative'] - Key formatting style
+ * @returns {Promise<Record<string, Function | Promise<any>>>}
+ */
+export async function globImports(
+  pattern = './src/pages/**/*.{js,ts,jsx,tsx}',
+  { cwd = process.cwd(), eager = false, keyType = 'relative' } = {}
+) {
+  const relativePaths = await fg(pattern, { cwd, dot: false })
+  /** @type {Record<string, Function | Promise<any>>} */
+  const modules = {}
+
+  for (const relativePath of relativePaths) {
+    const absolutePath = path.resolve(cwd, relativePath)
+    const fileUrl = pathToFileURL(absolutePath).href
+
+    // Determine Key Format
+    let key
+    if (keyType === 'fileUrl') {
+      key = fileUrl
+    } else if (keyType === 'absolute') {
+      key = absolutePath.split(path.sep).join('/')
+    } else {
+      // Standard Vite 'relative' behavior
+      key = relativePath.split(path.sep).join('/')
+      if (!key.startsWith('.') && !key.startsWith('/')) {
+        key = `./${key}`
+      }
+    }
+
+    // Always use full fileUrl for the actual import
+    if (eager) {
+      modules[key] = await import(/* @vite-ignore */ fileUrl)
+    } else {
+      modules[key] = () => import(/* @vite-ignore */ fileUrl)
+    }
+  }
+
+  return modules
+}

package/src/server-only-utils/index.js

@@ -1,9 +1 @@
-export * from "./renderToString.js";
-export * from "./renderDomToString.js";
-export * from "./glob-imports.js";
-export * from "./write-to-dist.js";
-export * from './manifest-parser.js';
-export * from './import-prerendered-routes.js'
-export * from './import-middlwares.js'
-export * from './resolve-static-routes.js'
-export * from './read-files.js'
+export * from './globImports.js'

package/README.md

@@ -1,72 +0,0 @@
-[![ziko-server banner](https://raw.githubusercontent.com/zikojs/.github/main/assets/banners/ziko-server.svg)](https://github.com/zikojs)
-
-# Ziko-server
-
-Server-side rendering for Zikojs with file-based routing and client-side hydration.
-
-# Features 
-- ✅ Server Side Rendering 
-- ✅ Client Side Hydration with no additional config 
-- ✅ File Based Routing 
-- ✅ Mdzjs Supports
-- ✅ Supports Dynamic Routes
-- ✅ Supports both Sync And Async rendering
-- ✅ Supports API
-
-<!-- 
-compare with type
- -->
-
-# Project Structure
-```
-App
-   ├──public/ 
-   ├── src/
-      ├── .ziko  #generated
-      ├── pages/ # required
-            ├── index.js 
-      ├── components/
-      ├── layouts/
-      ├── contents/
-      ├── db/
-      ├── i18n/
-      ├── middlewares.js
-   ├── tsconfig.json
-   ├── ziko.config.js
-   ├── package.json
-    
-```
-
-
-# Config 
-
-```js
-// server.js
-import { createServer } from "ziko-server/server";
-createServer()
-```
-
-```js
-// entry-server.js
-import {defineServerEntry} from "ziko-server/entry-server";
-export default defineServerEntry({
-   pages : import.meta.glob("./pages/**/*{.js,.mdz}")
-})
-```
-```js
-// entry-client.js
-import {EntryClient} from "ziko-server/entry-client";
-EntryClient({
-  pages : import.meta.glob("./pages/**/*{.js,.mdz}")
-})
-```
-
-# ⭐️ Show your support
-
-If you appreciate the project, kindly demonstrate your support by giving it a star!<br>
-
-[![Star](https://img.shields.io/github/stars/zakarialaoui10/ziko-server?style=social)](https://github.com/zakarialaoui10/ziko-server)
-<!--## Financial support-->
-# License 
-This projet is licensed under the terms of MIT License 
-<img src="https://img.shields.io/github/license/zakarialaoui10/ziko-server?color=rgb%2820%2C21%2C169%29" width="100" align="right">