appstage 0.2.7 → 0.2.9

package/dist/bin.js

@@ -433,12 +433,9 @@ async function getEntryPoints(path) {
 }
 
 // src/scripts/utils/buildClient.ts
+var entryClientPaths = ["ui/index", "client/index", "index", "src/index"];
 async function buildClient({ clientDir, watch, watchClient }, plugins) {
-  let clientEntries = await getEntryPoints([
-    "ui/index",
-    "client/index",
-    "index"
-  ]);
+  let clientEntries = await getEntryPoints(entryClientPaths);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: clientEntries.map(({ path }) => path),
@@ -502,12 +499,13 @@ ${content}
 }
 
 // src/scripts/utils/buildServer.ts
+var appServerEntryPoints = ["src/server/index.ts"];
 async function buildServer(params, plugins) {
   let { serverDir, watch, watchServer } = params;
   await populateEntries(params);
   let buildOptions = {
     ...commonBuildOptions,
-    entryPoints: ["src/server/index.ts"],
+    entryPoints: appServerEntryPoints,
     bundle: true,
     splitting: true,
     outdir: `${serverDir}/server`,
@@ -528,8 +526,9 @@ async function buildServer(params, plugins) {
 
 // src/scripts/utils/buildServerCSS.ts
 import esbuild3 from "esbuild";
+var entryServerPaths = ["server", "server/index"];
 async function buildServerCSS({ serverDir, watch, watchServer }, plugins) {
-  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let serverEntries = await getEntryPoints(entryServerPaths);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: serverEntries.map(({ name, path }) => ({

package/dist/index.cjs

@@ -124,6 +124,85 @@ const dir = ({ path, name = defaultName, ext = defaultExt, transform, supportedL
   };
 };
 
+const maxLanguages = 3;
+async function resolve(...parts) {
+  let fullPath = (0, node_path.join)(...parts);
+  try {
+    if ((await (0, node_fs_promises.lstat)(fullPath)).isFile()) return fullPath;
+  } catch {}
+  return null;
+}
+function getLanguageList(acceptedLanguages) {
+  let langs = /* @__PURE__ */ new Set();
+  for (let i = 0; i < acceptedLanguages.length && i < maxLanguages; i++) {
+    let s = acceptedLanguages[i];
+    let [lang] = s.split(/[-_]/);
+    if (s === lang) langs.add(s);
+    else {
+      langs.add(s);
+      langs.add(lang);
+    }
+  }
+  return Array.from(langs);
+}
+const defaultExtensions = ["html", "htm"];
+const defaultPath = (req) => req.originalUrl.split("?")[0];
+/**
+* Serves files from the specified directory path in a locale-aware
+* fashion after applying optional transforms.
+*/
+const files = (params) => {
+  let p = typeof params === "string" ? { base: params } : params;
+  let bases = Array.isArray(p.base) ? p.base : [p.base];
+  let exts = p.extensions ?? defaultExtensions;
+  return async (req, res) => {
+    let langs = getLanguageList(req.acceptsLanguages());
+    let path = typeof p.path === "string" ? p.path : (p.path ?? defaultPath)(req);
+    if (path.includes("../")) {
+      emitLog(req.app, "Invalid path (potential traversal attempt)", { data: { path } });
+      res.status(400).send(await req.app.renderStatus?.(req, res, {
+        code: "invalid_path",
+        path
+      }));
+      return;
+    }
+    let filePath = null;
+    for (let k = 0; k < bases.length && filePath === null; k++) {
+      let base = bases[k];
+      for (let i = 0; i < langs.length && filePath === null; i++) filePath = await resolve(base, `${path}.${langs[i]}`);
+      if (filePath === null) filePath = await resolve(base, path);
+      for (let i = 0; i < langs.length && filePath === null; i++) for (let j = 0; j < exts.length && filePath === null; j++) filePath = await resolve(base, `${path}.${langs[i]}.${exts[j]}`);
+      for (let i = 0; i < exts.length && filePath === null; i++) filePath = await resolve(base, `${path}.${exts[i]}`);
+      for (let i = 0; i < langs.length && filePath === null; i++) for (let j = 0; j < exts.length && filePath === null; j++) filePath = await resolve(base, `${path}.${langs[i]}`, `index.${exts[j]}`);
+      for (let i = 0; i < langs.length && filePath === null; i++) for (let j = 0; j < exts.length && filePath === null; j++) filePath = await resolve(base, path, `index.${langs[i]}.${exts[j]}`);
+      for (let i = 0; i < exts.length && filePath === null; i++) filePath = await resolve(base, path, `index.${exts[i]}`);
+    }
+    if (filePath === null) {
+      emitLog(req.app, "Unknown path", { data: { path } });
+      res.status(404).send(await req.app.renderStatus?.(req, res, {
+        code: "unknown_path",
+        path
+      }));
+      return;
+    }
+    if (!p.transform?.length) {
+      res.sendFile(filePath);
+      return;
+    }
+    let content = (await (0, node_fs_promises.readFile)(filePath)).toString();
+    let name = (0, node_path.basename)(filePath);
+    for (let transform of p.transform) {
+      let result = transform(req, res, {
+        content,
+        path,
+        name
+      });
+      content = result instanceof Promise ? await result : result;
+    }
+    res.type((0, node_path.extname)(name).slice(1)).send(content);
+  };
+};
+
 const unhandledError = () => async (err, req, res) => {
   emitLog(req.app, "Unhandled error", {
     level: "error",
@@ -363,15 +442,17 @@ async function getEntryPoints(path) {
   }))).filter((item) => item !== void 0);
 }
 
+const entryClientPaths = [
+  "ui/index",
+  "client/index",
+  "index",
+  "src/index"
+];
 /**
 * Builds the client-side code.
 */
 async function buildClient({ clientDir, watch, watchClient }, plugins) {
-  let clientEntries = await getEntryPoints([
-    "ui/index",
-    "client/index",
-    "index"
-  ]);
+  let clientEntries = await getEntryPoints(entryClientPaths);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: clientEntries.map(({ path }) => path),
@@ -417,12 +498,13 @@ ${content}
 `);
 }
 
+const appServerEntryPoints = ["src/server/index.ts"];
 async function buildServer(params, plugins) {
   let { serverDir, watch, watchServer } = params;
   await populateEntries(params);
   let buildOptions = {
     ...commonBuildOptions,
-    entryPoints: ["src/server/index.ts"],
+    entryPoints: appServerEntryPoints,
     bundle: true,
     splitting: true,
     outdir: `${serverDir}/server`,
@@ -441,8 +523,9 @@ async function buildServer(params, plugins) {
   await esbuild.default.build(buildOptions);
 }
 
+const entryServerPaths = ["server", "server/index"];
 async function buildServerCSS({ serverDir, watch, watchServer }, plugins) {
-  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let serverEntries = await getEntryPoints(entryServerPaths);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: serverEntries.map(({ name, path }) => ({
@@ -635,6 +718,7 @@ exports.createApp = createApp;
 exports.cspNonce = cspNonce;
 exports.dir = dir;
 exports.emitLog = emitLog;
+exports.files = files;
 exports.getEffectiveLocale = getEffectiveLocale;
 exports.getLocales = getLocales;
 exports.getStatusMessage = getStatusMessage;

package/dist/index.d.ts

@@ -75,6 +75,18 @@ type DirParams = Partial<Pick<ResolveFilePathParams, "supportedLocales" | "index
  */
 declare const dir$1: Controller<DirParams>;
 
+type FilesParams = {
+  base: string | string[];
+  path?: string | ((req: Request) => string);
+  extensions?: string[];
+  transform?: TransformContent[];
+};
+/**
+ * Serves files from the specified directory path in a locale-aware
+ * fashion after applying optional transforms.
+ */
+declare const files: Controller<string | FilesParams>;
+
 type ErrorController<T = void> = (params: T) => ErrorRequestHandler;
 
 declare const unhandledError: ErrorController;
@@ -1166,4 +1178,4 @@ declare function servePipeableStream(req: Request, res: Response): ({
   pipe
 }: PipeableStream, error?: unknown) => Promise<void>;
 
-export { Controller, DirParams, ErrorController, LangParams, LogEventPayload, LogLevel, LogOptions, Middleware, MiddlewareSet, RenderStatus, ReqCtx, ResolveFilePathParams, TransformContent, build, cli, createApp, cspNonce, dir$1 as dir, emitLog, getEffectiveLocale, getLocales, getStatusMessage, init, injectNonce, lang$1 as lang, log, renderStatus, requestEvents, resolveFilePath, serializeState, servePipeableStream, toLanguage, unhandledError, unhandledRoute };
+export { Controller, DirParams, ErrorController, FilesParams, LangParams, LogEventPayload, LogLevel, LogOptions, Middleware, MiddlewareSet, RenderStatus, ReqCtx, ResolveFilePathParams, TransformContent, build, cli, createApp, cspNonce, dir$1 as dir, emitLog, files, getEffectiveLocale, getLocales, getStatusMessage, init, injectNonce, lang$1 as lang, log, renderStatus, requestEvents, resolveFilePath, serializeState, servePipeableStream, toLanguage, unhandledError, unhandledRoute };

package/dist/index.mjs

@@ -98,6 +98,85 @@ const dir = ({ path, name = defaultName, ext = defaultExt, transform, supportedL
   };
 };
 
+const maxLanguages = 3;
+async function resolve(...parts) {
+  let fullPath = join(...parts);
+  try {
+    if ((await lstat(fullPath)).isFile()) return fullPath;
+  } catch {}
+  return null;
+}
+function getLanguageList(acceptedLanguages) {
+  let langs = /* @__PURE__ */ new Set();
+  for (let i = 0; i < acceptedLanguages.length && i < maxLanguages; i++) {
+    let s = acceptedLanguages[i];
+    let [lang] = s.split(/[-_]/);
+    if (s === lang) langs.add(s);
+    else {
+      langs.add(s);
+      langs.add(lang);
+    }
+  }
+  return Array.from(langs);
+}
+const defaultExtensions = ["html", "htm"];
+const defaultPath = (req) => req.originalUrl.split("?")[0];
+/**
+* Serves files from the specified directory path in a locale-aware
+* fashion after applying optional transforms.
+*/
+const files = (params) => {
+  let p = typeof params === "string" ? { base: params } : params;
+  let bases = Array.isArray(p.base) ? p.base : [p.base];
+  let exts = p.extensions ?? defaultExtensions;
+  return async (req, res) => {
+    let langs = getLanguageList(req.acceptsLanguages());
+    let path = typeof p.path === "string" ? p.path : (p.path ?? defaultPath)(req);
+    if (path.includes("../")) {
+      emitLog(req.app, "Invalid path (potential traversal attempt)", { data: { path } });
+      res.status(400).send(await req.app.renderStatus?.(req, res, {
+        code: "invalid_path",
+        path
+      }));
+      return;
+    }
+    let filePath = null;
+    for (let k = 0; k < bases.length && filePath === null; k++) {
+      let base = bases[k];
+      for (let i = 0; i < langs.length && filePath === null; i++) filePath = await resolve(base, `${path}.${langs[i]}`);
+      if (filePath === null) filePath = await resolve(base, path);
+      for (let i = 0; i < langs.length && filePath === null; i++) for (let j = 0; j < exts.length && filePath === null; j++) filePath = await resolve(base, `${path}.${langs[i]}.${exts[j]}`);
+      for (let i = 0; i < exts.length && filePath === null; i++) filePath = await resolve(base, `${path}.${exts[i]}`);
+      for (let i = 0; i < langs.length && filePath === null; i++) for (let j = 0; j < exts.length && filePath === null; j++) filePath = await resolve(base, `${path}.${langs[i]}`, `index.${exts[j]}`);
+      for (let i = 0; i < langs.length && filePath === null; i++) for (let j = 0; j < exts.length && filePath === null; j++) filePath = await resolve(base, path, `index.${langs[i]}.${exts[j]}`);
+      for (let i = 0; i < exts.length && filePath === null; i++) filePath = await resolve(base, path, `index.${exts[i]}`);
+    }
+    if (filePath === null) {
+      emitLog(req.app, "Unknown path", { data: { path } });
+      res.status(404).send(await req.app.renderStatus?.(req, res, {
+        code: "unknown_path",
+        path
+      }));
+      return;
+    }
+    if (!p.transform?.length) {
+      res.sendFile(filePath);
+      return;
+    }
+    let content = (await readFile(filePath)).toString();
+    let name = basename(filePath);
+    for (let transform of p.transform) {
+      let result = transform(req, res, {
+        content,
+        path,
+        name
+      });
+      content = result instanceof Promise ? await result : result;
+    }
+    res.type(extname(name).slice(1)).send(content);
+  };
+};
+
 const unhandledError = () => async (err, req, res) => {
   emitLog(req.app, "Unhandled error", {
     level: "error",
@@ -337,15 +416,17 @@ async function getEntryPoints(path) {
   }))).filter((item) => item !== void 0);
 }
 
+const entryClientPaths = [
+  "ui/index",
+  "client/index",
+  "index",
+  "src/index"
+];
 /**
 * Builds the client-side code.
 */
 async function buildClient({ clientDir, watch, watchClient }, plugins) {
-  let clientEntries = await getEntryPoints([
-    "ui/index",
-    "client/index",
-    "index"
-  ]);
+  let clientEntries = await getEntryPoints(entryClientPaths);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: clientEntries.map(({ path }) => path),
@@ -391,12 +472,13 @@ ${content}
 `);
 }
 
+const appServerEntryPoints = ["src/server/index.ts"];
 async function buildServer(params, plugins) {
   let { serverDir, watch, watchServer } = params;
   await populateEntries(params);
   let buildOptions = {
     ...commonBuildOptions,
-    entryPoints: ["src/server/index.ts"],
+    entryPoints: appServerEntryPoints,
     bundle: true,
     splitting: true,
     outdir: `${serverDir}/server`,
@@ -415,8 +497,9 @@ async function buildServer(params, plugins) {
   await esbuild.build(buildOptions);
 }
 
+const entryServerPaths = ["server", "server/index"];
 async function buildServerCSS({ serverDir, watch, watchServer }, plugins) {
-  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let serverEntries = await getEntryPoints(entryServerPaths);
   let buildOptions = {
     ...commonBuildOptions,
     entryPoints: serverEntries.map(({ name, path }) => ({
@@ -603,4 +686,4 @@ function servePipeableStream(req, res) {
   };
 }
 
-export { build, cli, createApp, cspNonce, dir, emitLog, getEffectiveLocale, getLocales, getStatusMessage, init, injectNonce, lang, log, renderStatus, requestEvents, resolveFilePath, serializeState, servePipeableStream, toLanguage, unhandledError, unhandledRoute };
+export { build, cli, createApp, cspNonce, dir, emitLog, files, getEffectiveLocale, getLocales, getStatusMessage, init, injectNonce, lang, log, renderStatus, requestEvents, resolveFilePath, serializeState, servePipeableStream, toLanguage, unhandledError, unhandledRoute };

package/index.ts

@@ -1,4 +1,5 @@
 export * from "./src/controllers/dir.ts";
+export * from "./src/controllers/files.ts";
 export * from "./src/controllers/unhandledError.ts";
 export * from "./src/controllers/unhandledRoute.ts";
 export * from "./src/lib/lang/getEffectiveLocale.ts";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "appstage",
-  "version": "0.2.7",
+  "version": "0.2.9",
   "description": "",
   "main": "./dist/index.cjs",
   "module": "./dist/index.mjs",

package/src/controllers/files.ts

@@ -0,0 +1,151 @@
+import { lstat, readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import type { Request } from "express";
+import type { Controller } from "../types/Controller.ts";
+import type { TransformContent } from "../types/TransformContent.ts";
+import { emitLog } from "../utils/emitLog.ts";
+
+const maxLanguages = 3;
+
+async function resolve(...parts: string[]) {
+  let fullPath = join(...parts);
+  try {
+    if ((await lstat(fullPath)).isFile()) return fullPath;
+  } catch {}
+  return null;
+}
+
+// ["en-US", "ru"] > ["en-US", "en", "ru"]
+function getLanguageList(acceptedLanguages: string[]) {
+  let langs = new Set<string>();
+
+  for (let i = 0; i < acceptedLanguages.length && i < maxLanguages; i++) {
+    let s = acceptedLanguages[i];
+    let [lang] = s.split(/[-_]/);
+
+    if (s === lang) langs.add(s);
+    else {
+      langs.add(s);
+      langs.add(lang);
+    }
+  }
+
+  return Array.from(langs);
+}
+
+export type FilesParams = {
+  base: string | string[];
+  path?: string | ((req: Request) => string);
+  extensions?: string[];
+  transform?: TransformContent[];
+};
+
+const defaultExtensions = ["html", "htm"];
+const defaultPath = (req: Request) => req.originalUrl.split("?")[0];
+
+/**
+ * Serves files from the specified directory path in a locale-aware
+ * fashion after applying optional transforms.
+ */
+export const files: Controller<string | FilesParams> = (params) => {
+  let p: FilesParams = typeof params === "string" ? { base: params } : params;
+
+  let bases = Array.isArray(p.base) ? p.base : [p.base];
+  let exts = p.extensions ?? defaultExtensions;
+
+  return async (req, res) => {
+    let langs = getLanguageList(req.acceptsLanguages());
+
+    let path =
+      typeof p.path === "string" ? p.path : (p.path ?? defaultPath)(req);
+
+    if (path.includes("../")) {
+      emitLog(req.app, "Invalid path (potential traversal attempt)", {
+        data: { path },
+      });
+
+      res.status(400).send(
+        await req.app.renderStatus?.(req, res, {
+          code: "invalid_path",
+          path,
+        }),
+      );
+
+      return;
+    }
+
+    // path: /x
+    // langs: en, ru
+    let filePath: string | null = null;
+
+    for (let k = 0; k < bases.length && filePath === null; k++) {
+      let base = bases[k];
+
+      // /x.en /x.ru
+      for (let i = 0; i < langs.length && filePath === null; i++)
+        filePath = await resolve(base, `${path}.${langs[i]}`);
+
+      // /x
+      if (filePath === null) filePath = await resolve(base, path);
+
+      // /x.en.html /x.en.htm /x.ru.html /x.ru.htm
+      for (let i = 0; i < langs.length && filePath === null; i++) {
+        for (let j = 0; j < exts.length && filePath === null; j++)
+          filePath = await resolve(base, `${path}.${langs[i]}.${exts[j]}`);
+      }
+
+      // /x.html /x.htm
+      for (let i = 0; i < exts.length && filePath === null; i++)
+        filePath = await resolve(base, `${path}.${exts[i]}`);
+
+      // /x.en/index.html /x.en/index.htm /x.ru/index.html /x.ru/index.htm
+      for (let i = 0; i < langs.length && filePath === null; i++) {
+        for (let j = 0; j < exts.length && filePath === null; j++)
+          filePath = await resolve(
+            base,
+            `${path}.${langs[i]}`,
+            `index.${exts[j]}`,
+          );
+      }
+
+      // /x/index.en.html /x/index.en.htm /x/index.ru.html /x/index.ru.htm
+      for (let i = 0; i < langs.length && filePath === null; i++) {
+        for (let j = 0; j < exts.length && filePath === null; j++)
+          filePath = await resolve(base, path, `index.${langs[i]}.${exts[j]}`);
+      }
+
+      // /x/index.html /x/index.htm
+      for (let i = 0; i < exts.length && filePath === null; i++)
+        filePath = await resolve(base, path, `index.${exts[i]}`);
+    }
+
+    if (filePath === null) {
+      emitLog(req.app, "Unknown path", { data: { path } });
+
+      res.status(404).send(
+        await req.app.renderStatus?.(req, res, {
+          code: "unknown_path",
+          path,
+        }),
+      );
+
+      return;
+    }
+
+    if (!p.transform?.length) {
+      res.sendFile(filePath);
+      return;
+    }
+
+    let content = (await readFile(filePath)).toString();
+    let name = basename(filePath);
+
+    for (let transform of p.transform) {
+      let result = transform(req, res, { content, path, name });
+
+      content = result instanceof Promise ? await result : result;
+    }
+
+    res.type(extname(name).slice(1)).send(content);
+  };
+};

package/src/scripts/utils/buildClient.ts

@@ -3,6 +3,8 @@ import { commonBuildOptions } from "../const/commonBuildOptions.ts";
 import type { BuildParams } from "../types/BuildParams.ts";
 import { getEntryPoints } from "./getEntryPoints.ts";
 
+const entryClientPaths = ["ui/index", "client/index", "index", "src/index"];
+
 /**
  * Builds the client-side code.
  */
@@ -10,11 +12,7 @@ export async function buildClient(
   { clientDir, watch, watchClient }: BuildParams,
   plugins?: Plugin[],
 ) {
-  let clientEntries = await getEntryPoints([
-    "ui/index",
-    "client/index",
-    "index",
-  ]);
+  let clientEntries = await getEntryPoints(entryClientPaths);
 
   let buildOptions: BuildOptions = {
     ...commonBuildOptions,

package/src/scripts/utils/buildServer.ts

@@ -3,6 +3,8 @@ import { commonBuildOptions } from "../const/commonBuildOptions.ts";
 import type { BuildParams } from "../types/BuildParams.ts";
 import { populateEntries } from "./populateEntries.ts";
 
+const appServerEntryPoints = ["src/server/index.ts"];
+
 export async function buildServer(params: BuildParams, plugins?: Plugin[]) {
   let { serverDir, watch, watchServer } = params;
 
@@ -10,7 +12,7 @@ export async function buildServer(params: BuildParams, plugins?: Plugin[]) {
 
   let buildOptions: BuildOptions = {
     ...commonBuildOptions,
-    entryPoints: ["src/server/index.ts"],
+    entryPoints: appServerEntryPoints,
     bundle: true,
     splitting: true,
     outdir: `${serverDir}/server`,

package/src/scripts/utils/buildServerCSS.ts

@@ -3,11 +3,13 @@ import { commonBuildOptions } from "../const/commonBuildOptions.ts";
 import type { BuildParams } from "../types/BuildParams.ts";
 import { getEntryPoints } from "./getEntryPoints.ts";
 
+const entryServerPaths = ["server", "server/index"];
+
 export async function buildServerCSS(
   { serverDir, watch, watchServer }: BuildParams,
   plugins?: Plugin[],
 ) {
-  let serverEntries = await getEntryPoints(["server", "server/index"]);
+  let serverEntries = await getEntryPoints(entryServerPaths);
 
   let buildOptions: BuildOptions = {
     ...commonBuildOptions,