glashjs 0.12.1 → 0.13.0

package/src/index.mjs

@@ -4,11 +4,13 @@ export { build } from './build.mjs';
 export { deploy } from './deploy.mjs';
 export { update } from './update.mjs';
 export { migrate } from './migrate.mjs';
+export { createProject } from './create.mjs';
 export { optimizeAssets } from './assets/optimize.mjs';
 export { generateAnimatedFavicon } from './assets/animated-favicon.mjs';
 export { generateServiceWorker } from './offline/generate-sw.mjs';
 export { securityHeaders, buildCsp, sri, glashSecurity } from './security/headers.mjs';
 export { createGlashServer, json, redirect } from './server/server.mjs';
+export { serverFunction, callServerFunction } from './server-functions.mjs';
 export { discoverRoutes, matchRoute, findMiddleware } from './server/router.mjs';
 export { html, raw, escapeHtml, renderDocument, renderMeta } from './server/html.mjs';
 // NOTE: <Image>/<Video>/<Link> are Preact components, so they live on subpaths

package/src/postgres.mjs

@@ -0,0 +1,77 @@
+// glashjs Postgres helpers
+// ---------------------------------------------------------------------------
+// GlashDB projects get Postgres by default. This module gives server routes,
+// API routes, and server functions a tiny query layer over `pg`.
+
+import pg from 'pg';
+
+const { Pool } = pg;
+let defaultPool;
+let defaultPoolKey = '';
+
+export function createPostgresPool(options = {}) {
+  const connectionString = options.connectionString ?? process.env.DATABASE_URL;
+  if (!connectionString) throw new Error('DATABASE_URL is required for glashjs/postgres');
+  return new Pool({
+    connectionString,
+    ssl: options.ssl ?? sslFor(connectionString),
+    max: options.max ?? 10,
+    idleTimeoutMillis: options.idleTimeoutMillis ?? 30_000,
+    connectionTimeoutMillis: options.connectionTimeoutMillis ?? 10_000,
+    ...options.pool,
+  });
+}
+
+export function postgres(options = {}) {
+  const connectionString = options.connectionString ?? process.env.DATABASE_URL;
+  if (!connectionString) throw new Error('DATABASE_URL is required for glashjs/postgres');
+  const key = `${connectionString}|${JSON.stringify(options.pool || {})}`;
+  if (!defaultPool || defaultPoolKey !== key) {
+    defaultPool = createPostgresPool(options);
+    defaultPoolKey = key;
+  }
+  return defaultPool;
+}
+
+export async function query(text, params = [], options = {}) {
+  return postgres(options).query(text, params);
+}
+
+export async function sql(strings, ...values) {
+  if (typeof strings === 'string') return query(strings, values[0] ?? []);
+  const text = templateToSql(strings, values);
+  return query(text, values);
+}
+
+sql.query = query;
+sql.pool = postgres;
+
+export async function transaction(fn, options = {}) {
+  const client = await postgres(options).connect();
+  try {
+    await client.query('BEGIN');
+    const result = await fn(client);
+    await client.query('COMMIT');
+    return result;
+  } catch (error) {
+    await client.query('ROLLBACK').catch(() => undefined);
+    throw error;
+  } finally {
+    client.release();
+  }
+}
+
+function templateToSql(strings, values) {
+  let text = '';
+  for (let i = 0; i < strings.length; i += 1) {
+    text += strings[i];
+    if (i < values.length) text += `$${i + 1}`;
+  }
+  return text;
+}
+
+function sslFor(connectionString) {
+  if (/sslmode=disable/i.test(connectionString)) return false;
+  if (/localhost|127\.0\.0\.1|::1/.test(connectionString)) return false;
+  return { rejectUnauthorized: true };
+}

package/src/routes.mjs

@@ -0,0 +1,7 @@
+// Runtime companion for generated glashjs route types.
+// TypeScript users get strict route literals from `glashjs typegen`; JavaScript
+// users can call route("/path") as a tiny self-documenting helper.
+
+export function route(path) {
+  return path;
+}

package/src/server/jsx.mjs

@@ -1,7 +1,7 @@
 // glashjs JSX + hydration engine
 // ---------------------------------------------------------------------------
-// This is the layer that makes glashjs a real Next.js alternative: author
-// pages as JSX components, render them on the server, and HYDRATE them in the
+// This is the layer that lets glashjs author pages as JSX components, render
+// them on the server, and HYDRATE them in the
 // browser so hooks (useState/useEffect) work — true interactivity.
 //
 // Built on proven primitives, added as OPTIONAL peers so glashjs core stays
@@ -113,7 +113,7 @@ const compId = (pageFile, layouts) => routeId(pageFile + '|' + layouts.join('|')
 function serverEntry(pageFile, layouts) {
   const lines = [`import * as __p from ${JSON.stringify(pageFile)};`];
   layouts.forEach((f, i) => lines.push(`import __L${i} from ${JSON.stringify(f)};`));
-  lines.push('export const Page = __p.default;', 'export const getServerData = __p.getServerData;', 'export const title = __p.title;', 'export const metadata = __p.metadata;');
+  lines.push('export const Page = __p.default;', 'export const getServerData = __p.getServerData;', 'export const title = __p.title;', 'export const metadata = __p.metadata;', 'export const stream = __p.stream;');
   lines.push(`export const layouts = [${layouts.map((_, i) => `__L${i}`).join(',')}];`);
   return lines.join('\n');
 }

package/src/server/server.mjs

@@ -17,6 +17,7 @@ import { NAV_CLIENT } from './nav-client.mjs';
 import { isComponentRoute, loadComponentRoute, clientBundle, renderComponent, composeVNode, getPipeableRenderer, routeId, findLayouts, clearJsxCaches, compileModule } from './jsx.mjs';
 import { securityHeaders } from '../security/headers.mjs';
 import { loadConfig } from '../config.mjs';
+import { loadEnvFiles } from '../env.mjs';
 
 const MIME = {
   '.html': 'text/html; charset=utf-8', '.js': 'text/javascript', '.mjs': 'text/javascript',
@@ -29,6 +30,7 @@ const mime = (file) => MIME[path.extname(file).toLowerCase()] || 'application/oc
 
 /** Build the glashjs server. Returns { server, listen, cfg }. */
 export async function createGlashServer({ root = process.cwd(), dev = false } = {}) {
+  loadEnvFiles(root);
   const cfg = await loadConfig(root);
   const routesDir = path.resolve(root, cfg.routesDir || 'routes');
   const outDir = path.resolve(root, cfg.outDir);
@@ -156,7 +158,7 @@ async function handlePage(res, mod, ctx, cfg, secHeaders, dev) {
   const meta = await resolveMeta(page.metadata || mod.metadata, ctx);
   const docHtml = renderDocument({
     title: meta.title || page.title || mod.title || cfg.name,
-    head: renderMeta(meta) + (page.head ? (page.head.__raw || page.head) : ''),
+    head: renderStylesheets(cfg) + renderMeta(meta) + (page.head ? (page.head.__raw || page.head) : ''),
     body: page.body ?? '',
     offline: cfg.offline,
     animatedFavicon: !!cfg.animatedFavicon,
@@ -183,7 +185,7 @@ async function handleComponentPage(res, route, ctx, cfg, secHeaders, root, route
   const nonce = randomBytes(16).toString('base64');
   // Props in a non-executed JSON block (CSP-safe); hydration bundle is an
   // external 'self' module — both pass the strict CSP without 'unsafe-inline'.
-  const head = renderMeta(meta) + `<script type="application/json" id="glash-props">${safeJson(props)}</script>`;
+  const head = renderStylesheets(cfg) + renderMeta(meta) + `<script type="application/json" id="glash-props">${safeJson(props)}</script>`;
   const { open, tail } = documentParts({
     title, head, offline: cfg.offline, animatedFavicon: !!cfg.animatedFavicon, nonce, dev,
   });
@@ -195,7 +197,7 @@ async function handleComponentPage(res, route, ctx, cfg, secHeaders, root, route
   // then stream each boundary's real content as its data resolves. preact emits
   // inline <script> swap tags, so we inject this request's nonce into the stream
   // to keep the strict CSP intact.
-  const pipeable = await getPipeableRenderer();
+  const pipeable = mod.stream === true ? await getPipeableRenderer() : null;
   if (pipeable) {
     try {
       const vnode = await composeVNode(mod, props);
@@ -294,7 +296,7 @@ async function renderStandalone(route, ctx, cfg, root, routesDir, dev) {
     const props = (typeof mod.getServerData === 'function' ? await mod.getServerData(ctx) : {}) || {};
     const meta = await resolveMeta(mod.metadata, ctx);
     const rendered = await renderComponent(mod, props);
-    const head = renderMeta(meta) + `<script type="application/json" id="glash-props">${safeJson(props)}</script>`;
+    const head = renderStylesheets(cfg) + renderMeta(meta) + `<script type="application/json" id="glash-props">${safeJson(props)}</script>`;
     const body = `<div id="glash-root">${rendered}</div><script type="module" src="/_glash/${routeId(route.file)}.js"></script>`;
     return { html: renderDocument({ title: meta.title || mod.title || cfg.name, head, body, offline: cfg.offline, animatedFavicon: !!cfg.animatedFavicon, nonce, dev }), nonce };
   }
@@ -302,7 +304,15 @@ async function renderStandalone(route, ctx, cfg, root, routesDir, dev) {
   const out = typeof mod.default === 'function' ? await mod.default(ctx) : '';
   const page = typeof out === 'string' || (out && out.__raw) ? { body: out } : (out || {});
   const meta = await resolveMeta(page.metadata || mod.metadata, ctx);
-  return { html: renderDocument({ title: meta.title || page.title || mod.title || cfg.name, head: renderMeta(meta) + (page.head ? (page.head.__raw || page.head) : ''), body: page.body ?? '', offline: cfg.offline, animatedFavicon: !!cfg.animatedFavicon, nonce, dev }), nonce };
+  return { html: renderDocument({ title: meta.title || page.title || mod.title || cfg.name, head: renderStylesheets(cfg) + renderMeta(meta) + (page.head ? (page.head.__raw || page.head) : ''), body: page.body ?? '', offline: cfg.offline, animatedFavicon: !!cfg.animatedFavicon, nonce, dev }), nonce };
+}
+
+function renderStylesheets(cfg) {
+  const list = Array.isArray(cfg.stylesheets) ? cfg.stylesheets : [];
+  return list
+    .filter((href) => typeof href === 'string' && href.trim())
+    .map((href) => `<link rel="stylesheet" href="${escapeHtml(href.trim())}">`)
+    .join('');
 }
 
 /** 404: render a custom `404` route if present, else a clean default page. */

package/src/server-functions.mjs

@@ -0,0 +1,47 @@
+// glashjs server functions
+// ---------------------------------------------------------------------------
+// A small convention over API routes: wrap a trusted server-only function and
+// expose it as a JSON endpoint under routes/api/functions/*.
+
+export function serverFunction(handler, options = {}) {
+  const allowedMethods = new Set(options.methods ?? ['POST']);
+  return async function handleServerFunction(ctx) {
+    if (!allowedMethods.has(ctx.method)) {
+      return json({ ok: false, error: 'method not allowed' }, { status: 405 });
+    }
+    try {
+      const input = inputFor(ctx, options.input ?? 'auto');
+      const data = await handler(input, ctx);
+      return json({ ok: true, data });
+    } catch (error) {
+      const expose = options.exposeErrors ?? process.env.NODE_ENV !== 'production';
+      return json({
+        ok: false,
+        error: expose ? String(error?.message ?? error) : 'server function failed',
+      }, { status: error?.statusCode || error?.status || 500 });
+    }
+  };
+}
+
+function json(body, { status = 200, headers } = {}) {
+  return { __response: true, status, contentType: 'application/json', body, headers };
+}
+
+export async function callServerFunction(path, input, options = {}) {
+  const res = await fetch(path, {
+    method: options.method ?? 'POST',
+    headers: { 'content-type': 'application/json', ...(options.headers || {}) },
+    body: JSON.stringify(input ?? {}),
+  });
+  const body = await res.json().catch(() => null);
+  if (!res.ok || body?.ok === false) throw new Error(body?.error || `server function failed with HTTP ${res.status}`);
+  return body?.data;
+}
+
+function inputFor(ctx, mode) {
+  if (mode === 'body') return ctx.body ?? {};
+  if (mode === 'query') return ctx.query ?? {};
+  if (mode === 'params') return ctx.params ?? {};
+  if (ctx.method === 'GET') return ctx.query ?? {};
+  return ctx.body ?? {};
+}

package/src/sql-runner.mjs

@@ -0,0 +1,30 @@
+// glashjs SQL runner
+// ---------------------------------------------------------------------------
+// Runs checked-in SQL files against DATABASE_URL. Designed for local setup,
+// migrations, seed data, and glashDB-hosted projects.
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { query } from './postgres.mjs';
+import { loadEnvFiles } from './env.mjs';
+
+export async function runSqlFile(file, options = {}) {
+  if (!file) throw new Error('SQL file path is required');
+  const root = options.root ?? process.cwd();
+  loadEnvFiles(root);
+  const full = path.resolve(root, file);
+  const text = await fs.readFile(full, 'utf8');
+  const started = Date.now();
+  const result = await query(text, [], options);
+  return {
+    file: full,
+    rowCount: result.rowCount ?? 0,
+    ms: Date.now() - started,
+  };
+}
+
+export async function runSqlFiles(files, options = {}) {
+  const results = [];
+  for (const file of files) results.push(await runSqlFile(file, options));
+  return results;
+}

package/src/typed-routes.mjs

@@ -0,0 +1,65 @@
+// glashjs typed route generation
+// ---------------------------------------------------------------------------
+// Scans routes/ and writes a small TypeScript declaration file with literal
+// route unions. JS apps can ignore it; TS editors pick it up automatically.
+
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+import { discoverRoutes } from './server/router.mjs';
+import { loadConfig } from './config.mjs';
+
+export async function generateTypedRoutes({ root = process.cwd(), outFile = 'glash-routes.d.ts', log = console.log } = {}) {
+  const cfg = await loadConfig(root);
+  const routesDir = path.resolve(root, cfg.routesDir || 'routes');
+  const routes = await discoverRoutes(routesDir);
+  const pages = routes.filter((route) => !route.isApi).map((route) => toTsRoute(route.pattern));
+  const apis = routes.filter((route) => route.isApi).map((route) => toTsRoute(route.pattern));
+  const body = renderTypes({
+    pages: unique(pages),
+    apis: unique(apis),
+    generatedAt: new Date().toISOString(),
+  });
+  const target = path.resolve(root, outFile);
+  await fs.writeFile(target, body);
+  log(`glashjs typegen -> ${path.relative(root, target)} (${pages.length} page, ${apis.length} api)`);
+  return { outFile: target, pages: pages.length, apis: apis.length };
+}
+
+function renderTypes({ pages, apis, generatedAt }) {
+  const pageUnion = union(pages);
+  const apiUnion = union(apis);
+  return `// AUTO-GENERATED by glashjs typegen at ${generatedAt}
+// Do not edit by hand. Re-run: glashjs typegen
+
+declare module "glashjs/routes" {
+  export type GlashPageRoute = ${pageUnion};
+  export type GlashApiRoute = ${apiUnion};
+  export type GlashRoute = GlashPageRoute | GlashApiRoute;
+  export function route<T extends GlashRoute>(path: T): T;
+}
+
+export {};
+`;
+}
+
+function toTsRoute(pattern) {
+  if (pattern === '/') return '"/"';
+  const parts = pattern.split('/').filter(Boolean).map((part) => {
+    if (part.startsWith(':') || part.startsWith('*')) return '${string}';
+    return escapeTemplate(part);
+  });
+  if (parts.some((part) => part === '${string}')) return '`/' + parts.join('/') + '`';
+  return `"/${parts.join('/')}"`;
+}
+
+function union(values) {
+  return values.length ? values.join(' | ') : 'never';
+}
+
+function unique(values) {
+  return [...new Set(values)].sort();
+}
+
+function escapeTemplate(value) {
+  return value.replace(/[`$\\]/g, '\\$&');
+}