@starci/hfs 2.0.2 → 4.0.0

package/templates/fe/skeleton/apps/__app__/src/app/globals.css

@@ -1 +1,6 @@
 @import "tailwindcss";
+@import "@heroui/styles/css";
+@import "@starci/grammar/common.css";
+
+/* The grammar's renderers spell their layout in Tailwind utilities inside node_modules, which Tailwind never scans by default. */
+@source "../../../../../node_modules/@starci/grammar/dist";

package/templates/fe/skeleton/apps/__app__/src/components/composites/FailureScreen/index.tsx

@@ -0,0 +1,28 @@
+import { Button, GrammarRoot, Heading, PageContainer, WorkspaceShell } from "@starci/grammar/common"
+
+/** Props for {@link FailureScreen}. */
+type FailureScreenProps = {
+    /** What failed, said to the reader. */
+    readonly title: string
+    /** The label of the one recovery action. */
+    readonly retryLabel: string
+    /** Runs the recovery: the boundary re-renders what failed. */
+    readonly onRetry: () => void
+}
+
+/** A whole-screen failure with its one recovery action: the drawing both error boundaries share. */
+export const FailureScreen = (props: FailureScreenProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.title}
+            primary={
+                <PageContainer measure="reading">
+                    <Heading level={1}>{props.title}</Heading>
+                    <Button variant="danger" onPress={props.onRetry}>
+                        {props.retryLabel}
+                    </Button>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/layouts/LocaleShell/index.tsx

@@ -0,0 +1,35 @@
+import type { Metadata } from "next"
+import { notFound } from "next/navigation"
+import { hasLocale, NextIntlClientProvider } from "next-intl"
+import { getMessages, getTranslations, setRequestLocale } from "next-intl/server"
+import type { ReactNode } from "react"
+import { siteUrl } from "@/modules/config"
+import { routing } from "@/modules/i18n"
+
+type LocaleShellProps = {
+    readonly lang: string
+    readonly children: ReactNode
+}
+
+/** The document title and the absolute base of every metadata URL, for the language in the address. */
+export const localeMetadata = async (lang: string): Promise<Metadata> => {
+    if (!hasLocale(routing.locales, lang)) notFound()
+    const t = await getTranslations({ locale: lang, namespace: "app" })
+    return { title: t("title"), metadataBase: new URL(siteUrl()) }
+}
+
+/** The document of one route language: `<html lang>` from the address and the catalog handed to client components. */
+export const LocaleShell = async (props: LocaleShellProps) => {
+    if (!hasLocale(routing.locales, props.lang)) notFound()
+    setRequestLocale(props.lang)
+    const messages = await getMessages()
+    return (
+        <html lang={props.lang}>
+            <body className="min-h-dvh">
+                <NextIntlClientProvider locale={props.lang} messages={messages}>
+                    {props.children}
+                </NextIntlClientProvider>
+            </body>
+        </html>
+    )
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/ErrorPage/component.tsx

@@ -0,0 +1,21 @@
+import { FailureScreen } from "@/components/composites/FailureScreen"
+
+/** Props for {@link ErrorPageBase}. */
+export type ErrorPageBaseProps = {
+    /** Whole-screen situations this surface settles; the error page only ever shows the failure. */
+    readonly state: "failed"
+    /** The words the failure shows. */
+    readonly props: {
+        readonly title: string
+        readonly retryLabel: string
+    }
+    /** What the surface reports upward. */
+    readonly on: {
+        readonly retry: () => void
+    }
+}
+
+/** Draw the failure of the locale segment with its one recovery action. */
+export const ErrorPageBase = (props: ErrorPageBaseProps) => (
+    <FailureScreen title={props.props.title} retryLabel={props.props.retryLabel} onRetry={props.on.retry} />
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/ErrorPage/index.tsx

@@ -0,0 +1,17 @@
+import { useTranslations } from "next-intl"
+import { ErrorPageBase } from "./component"
+
+/** The public props of the locale error page: the boundary hands it the retry. */
+type ErrorPageProps = { readonly onRetry: () => void }
+
+/** A render failure of the locale segment shows this instead of a blank page; retry re-renders the segment. */
+export const ErrorPage = (props: ErrorPageProps) => {
+    const t = useTranslations("errors.page")
+    return (
+        <ErrorPageBase
+            state="failed"
+            props={{ title: t("title"), retryLabel: t("retry") }}
+            on={{ retry: props.onRetry }}
+        />
+    )
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/GlobalErrorPage/component.tsx

@@ -0,0 +1,26 @@
+import { FailureScreen } from "@/components/composites/FailureScreen"
+
+/** Props for {@link GlobalErrorPageBase}. */
+export type GlobalErrorPageBaseProps = {
+    /** Whole-screen situations this surface settles; the global error page only ever shows the failure. */
+    readonly state: "failed"
+    /** The language of the document and the words the failure shows. */
+    readonly props: {
+        readonly lang: string
+        readonly title: string
+        readonly retryLabel: string
+    }
+    /** What the surface reports upward. */
+    readonly on: {
+        readonly retry: () => void
+    }
+}
+
+/** Draw the whole document, because this boundary replaces the root layout that would have drawn it. */
+export const GlobalErrorPageBase = (props: GlobalErrorPageBaseProps) => (
+    <html lang={props.props.lang}>
+        <body>
+            <FailureScreen title={props.props.title} retryLabel={props.props.retryLabel} onRetry={props.on.retry} />
+        </body>
+    </html>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/GlobalErrorPage/index.tsx

@@ -0,0 +1,15 @@
+import { DEFAULT_LOCALE } from "@/modules/i18n"
+import messages from "@/modules/i18n/messages/vi.json"
+import { GlobalErrorPageBase } from "./component"
+
+/** The public props of the last-resort error page: the boundary hands it the retry. */
+type GlobalErrorPageProps = { readonly onRetry: () => void }
+
+/** The last-resort boundary above the locale layout: it has no provider, so it reads the default catalog directly. */
+export const GlobalErrorPage = (props: GlobalErrorPageProps) => (
+    <GlobalErrorPageBase
+        state="failed"
+        props={{ lang: DEFAULT_LOCALE, title: messages.errors.global.title, retryLabel: messages.errors.global.retry }}
+        on={{ retry: props.onRetry }}
+    />
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/HomePage/component.tsx

@@ -0,0 +1,25 @@
+import { GrammarRoot, Heading, PageContainer, WorkspaceShell } from "@starci/grammar/common"
+
+/** Props for {@link HomePageBase}. */
+export type HomePageBaseProps = {
+    /** Whole-screen situations this surface settles; the home page only ever shows its title. */
+    readonly state: "ready"
+    /** The words the page shows. */
+    readonly props: { readonly title: string }
+    /** What the surface reports upward; the page reports nothing. */
+    readonly on: Record<never, never>
+}
+
+/** Draw the front door of the app. */
+export const HomePageBase = (props: HomePageBaseProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.props.title}
+            primary={
+                <PageContainer measure="reading">
+                    <Heading level={1}>{props.props.title}</Heading>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/HomePage/index.tsx

@@ -0,0 +1,15 @@
+import type { Metadata } from "next"
+import { getTranslations } from "next-intl/server"
+import { HomePageBase } from "./component"
+
+/** The document title of the home page, from the catalog of the requested locale. */
+export const homeMetadata = async (): Promise<Metadata> => {
+    const t = await getTranslations("home")
+    return { title: t("title") }
+}
+
+/** The first page of the app: a server component, so no catalog is shipped for it. */
+export const HomePage = async () => {
+    const t = await getTranslations("home")
+    return <HomePageBase state="ready" props={{ title: t("title") }} on={{}} />
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/LoadingPage/component.tsx

@@ -0,0 +1,27 @@
+import { GrammarRoot, PageContainer, Text, WorkspaceShell } from "@starci/grammar/common"
+
+/** Props for {@link LoadingPageBase}. */
+export type LoadingPageBaseProps = {
+    /** Whole-screen situations this surface settles; the loading page only ever waits. */
+    readonly state: "loading"
+    /** The words the wait announces. */
+    readonly props: { readonly message: string }
+    /** What the surface reports upward; a wait reports nothing. */
+    readonly on: Record<never, never>
+}
+
+/** Draw the wait as one politely announced line. */
+export const LoadingPageBase = (props: LoadingPageBaseProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.props.message}
+            primary={
+                <PageContainer measure="reading">
+                    <Text live="polite" tone="muted">
+                        {props.props.message}
+                    </Text>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/LoadingPage/index.tsx

@@ -0,0 +1,8 @@
+import { getTranslations } from "next-intl/server"
+import { LoadingPageBase } from "./component"
+
+/** Shown while a route of the locale segment resolves. */
+export const LoadingPage = async () => {
+    const t = await getTranslations("loading")
+    return <LoadingPageBase state="loading" props={{ message: t("message") }} on={{}} />
+}

package/templates/fe/skeleton/apps/__app__/src/features/pages/NotFoundPage/component.tsx

@@ -0,0 +1,32 @@
+import { GrammarRoot, Heading, PageContainer, TextAction, WorkspaceShell } from "@starci/grammar/common"
+import { ROUTES } from "@/modules/routes"
+
+/** Props for {@link NotFoundPageBase}. */
+export type NotFoundPageBaseProps = {
+    /** Whole-screen situations this surface settles; the not-found page only ever says the page is missing. */
+    readonly state: "missing"
+    /** The words the page shows. */
+    readonly props: {
+        readonly title: string
+        readonly homeLabel: string
+    }
+    /** What the surface reports upward; the page reports nothing. */
+    readonly on: Record<never, never>
+}
+
+/** Draw the missing-page message and the way back to the front door. */
+export const NotFoundPageBase = (props: NotFoundPageBaseProps) => (
+    <GrammarRoot>
+        <WorkspaceShell
+            primaryLabel={props.props.title}
+            primary={
+                <PageContainer measure="reading">
+                    <Heading level={1}>{props.props.title}</Heading>
+                    <TextAction appearance="inline" href={ROUTES.home}>
+                        {props.props.homeLabel}
+                    </TextAction>
+                </PageContainer>
+            }
+        />
+    </GrammarRoot>
+)

package/templates/fe/skeleton/apps/__app__/src/features/pages/NotFoundPage/index.tsx

@@ -0,0 +1,8 @@
+import { getTranslations } from "next-intl/server"
+import { NotFoundPageBase } from "./component"
+
+/** Shown when a route calls `notFound()`. */
+export const NotFoundPage = async () => {
+    const t = await getTranslations("notFound")
+    return <NotFoundPageBase state="missing" props={{ title: t("title"), homeLabel: t("home") }} on={{}} />
+}

package/templates/fe/skeleton/apps/__app__/src/modules/config/index.ts

@@ -0,0 +1,12 @@
+/**
+ * The only reader of `process.env` in this app. A value is read when it is asked for, not when the file loads, and a
+ * missing value stops the caller with a named error: there is no localhost fallback.
+ */
+
+const required = (name: string, value: string | undefined): string => {
+    if (value === undefined || value === "") throw new Error(`${name} is not set`)
+    return value
+}
+
+/** The public origin of the app, the base of every absolute metadata URL; throws when `NEXT_PUBLIC_SITE_URL` is not set. */
+export const siteUrl = (): string => required("NEXT_PUBLIC_SITE_URL", process.env.NEXT_PUBLIC_SITE_URL)

package/templates/fe/skeleton/apps/__app__/src/modules/i18n/index.ts

@@ -0,0 +1,2 @@
+export { DEFAULT_LOCALE } from "./config"
+export { routing } from "./routing"

package/templates/fe/skeleton/apps/__app__/src/modules/i18n/messages/vi.json

@@ -1,7 +1,13 @@
 {
+  "app": {
+    "title": "{{project}}"
+  },
   "home": {
     "title": "Trang chủ"
   },
+  "loading": {
+    "message": "Đang tải"
+  },
   "notFound": {
     "title": "Không tìm thấy trang",
     "home": "Về trang chủ"

package/templates/fe/{skeleton-app → skeleton}/apps/__app__/src/modules/i18n/request.ts

@@ -1,3 +1,4 @@
+import "server-only"
 import { hasLocale } from "next-intl"
 import { getRequestConfig } from "next-intl/server"
 import { routing } from "./routing"

package/templates/fe/skeleton/apps/__app__/src/modules/routes/index.ts

@@ -0,0 +1,4 @@
+/** Every internal destination the screens link to, named once. */
+export const ROUTES = {
+    home: "/",
+} as const

package/templates/fe/{skeleton-app → skeleton}/apps/__app__/src/proxy.ts

@@ -1,5 +1,5 @@
 import createMiddleware from "next-intl/middleware"
-import { routing } from "./modules/i18n/routing"
+import { routing } from "./modules/i18n"
 
 /** Negotiates the locale and redirects; the default locale (vi) is served without a prefix. */
 export default createMiddleware(routing)

package/runtime/scripts/checks/architecture/size-growth.mjs

@@ -1,73 +0,0 @@
-import fs from 'node:fs';
-import { gitOutput } from '../../lib/git.mjs';
-
-/**
- * HFS check 6, file size growth (knowledge/hfs/slots.yaml ruleParams.<profile>.fileLines {soft, hardGrowth}):
- * a production source file over `soft` lines may not grow against the merge-base, and a file that is new at the base
- * must stay within `soft`. A file at or under `soft` passes, even when it grows, as long as it does not cross `soft`
- * (crossing is growth of an over-budget file: the base had fewer lines than soft). Files are compared to the base file
- * of the same path only, so a moved file is judged as new. The per-slot budgets (component 300, hook 200 ...) belong to
- * the lint layer and are not judged here.
- */
-export const SIZE_GROWTH_RULE_IDS = ['HFS_SIZE_GROWTH'];
-
-const MAX_BUFFER = 64 * 1024 * 1024;
-
-function git(root, args) {
-  try {
-    return gitOutput(args, { cwd: root, maxBuffer: MAX_BUFFER });
-  } catch {
-    return null;
-  }
-}
-
-/** The commit the growth is measured against: the given commit-ish, else merge-base with upstream, origin/main, origin/master, else HEAD's first parent. */
-function resolveBase(root, requested) {
-  const commit = (rev) => { const out = git(root, ['rev-parse', '--verify', '--quiet', `${rev}^{commit}`]); return out ? out.trim() : null; };
-  if (requested) return commit(requested);
-  if (!commit('HEAD')) return null;
-  for (const other of ['@{upstream}', 'origin/main', 'origin/master']) {
-    if (!commit(other)) continue;
-    const merged = git(root, ['merge-base', 'HEAD', other]);
-    if (merged?.trim()) return merged.trim();
-  }
-  return commit('HEAD^');
-}
-
-export function countLines(text) {
-  if (!text) return 0;
-  const count = text.split('\n').length;
-  return text.endsWith('\n') ? count - 1 : count;
-}
-
-export function checkSizeGrowth({ config, graph, base } = {}) {
-  const root = config.root;
-  const sha = resolveBase(root, base);
-  if (!sha) return { violations: [], coverage: { status: 'unavailable', reason: 'no merge-base' } };
-  const { soft, hardGrowth } = graph.resolver.ruleParams().fileLines;
-  const violations = [];
-  let files = 0;
-  let overSoft = 0;
-  let grown = 0;
-  let newOverSoft = 0;
-  for (const rel of [...graph.files.keys()].sort()) {
-    let text;
-    try { text = fs.readFileSync(graph.files.get(rel).abs, 'utf8'); } catch { continue; }
-    files += 1;
-    const lines = countLines(text);
-    if (lines <= soft) continue;
-    overSoft += 1;
-    const baseText = git(root, ['cat-file', 'blob', `${sha}:${rel}`]);
-    const baseLines = baseText === null ? null : countLines(baseText);
-    if (baseLines === null) {
-      newOverSoft += 1;
-      if (hardGrowth) violations.push({ ruleId: 'HFS_SIZE_GROWTH', path: rel, line: 1, lines, baseLines: null, soft,
-        message: `${rel} is a new file of ${lines} lines, over the ${soft}-line soft budget; split it into smaller files before adding it.` });
-    } else if (lines > baseLines) {
-      grown += 1;
-      if (hardGrowth) violations.push({ ruleId: 'HFS_SIZE_GROWTH', path: rel, line: 1, lines, baseLines, soft,
-        message: `${rel} has ${lines} lines, over the ${soft}-line soft budget, and grew from ${baseLines} lines at the base; a file over budget may only shrink, so split the new code into another file.` });
-    }
-  }
-  return { violations, coverage: { status: 'checked', base: sha, files, overSoft, grown, newOverSoft } };
-}

package/sync/skeleton.mjs

@@ -1,76 +0,0 @@
-// hfs sync --init: the first source tree of a new repository (entrypoint, platform config/logging/errors, the health
-// endpoint; for a front end the next-intl [locale] shell with vi default, as-needed prefix and proxy.ts).
-// Unlike the managed files it is written once and never overwritten: an existing file is skipped, so re-running --init
-// on a repository that already grew its own source changes nothing.
-//
-// A front end's skeleton is the templates/fe/skeleton tree (the app shell, common to every repository) plus ONE of two
-// trees for what a repository writes once: with one app the app keeps its own i18n stack and its own API client
-// (templates/fe/skeleton-app); with two or more apps the stack and the client are written once, as the packages
-// `packages/<project>-i18n` and `packages/<project>-api`, and each app keeps a thin adapter over them
-// (templates/fe/skeleton-shared). The choice is the number of apps in hfs.json, nothing else.
-import fs from 'node:fs';
-import path from 'node:path';
-import { TEMPLATES_DIR, SyncError, render, validateHfs } from './index.mjs';
-
-const APP_DIR = '__app__';
-const FAMILY_DIR = '__family__';
-/** The slots a multi-app front end must opt into in hfs.json before its shared packages are written. */
-export const SHARED_PACKAGE_SLOTS = Object.freeze(['fe.package.i18n', 'fe.package.api']);
-const pascal = name => name.split('-').map(part => part[0].toUpperCase() + part.slice(1)).join('');
-
-function listFiles(dir, base = dir) {
-  return fs.readdirSync(dir, { withFileTypes: true }).flatMap(entry => {
-    const full = path.join(dir, entry.name);
-    return entry.isDirectory() ? listFiles(full, base) : [path.relative(base, full).split(path.sep).join('/')];
-  });
-}
-
-/** The apps that get a skeleton: a back end's `api` apps, every front-end app. */
-export const skeletonApps = hfs => hfs.apps.filter(app => hfs.profile === 'fe' || app.kind === 'api');
-
-/** True when the repository writes its i18n stack and API client once, as packages: a front end with two or more apps. */
-export const sharesPackages = hfs => hfs.profile === 'fe' && hfs.apps.length > 1;
-
-/** The template directories of a repository, in order: the profile's skeleton, then (front end) the one-app or the shared-package tree. */
-export const skeletonDirs = hfs => [path.join(TEMPLATES_DIR, hfs.profile, 'skeleton'), ...(hfs.profile === 'fe' ? [path.join(TEMPLATES_DIR, 'fe', sharesPackages(hfs) ? 'skeleton-shared' : 'skeleton-app')] : [])];
-
-/** Every skeleton file for this repository: [{ path, content }], the shared ones once and the per-app ones per app. */
-export function skeletonFiles(hfs, dirs = skeletonDirs(hfs)) {
-  validateHfs(hfs);
-  if (sharesPackages(hfs)) {
-    const missing = SHARED_PACKAGE_SLOTS.filter(id => !(hfs.optionalSlots ?? []).includes(id));
-    if (missing.length) throw new SyncError('HFS_SYNC_HFS_INVALID', `a front end with ${hfs.apps.length} apps writes its i18n stack and its API client once, as packages: list ${missing.join(' and ')} in hfs.json optionalSlots before hfs sync --init`);
-  }
-  const files = [];
-  for (const dir of dirs) {
-    if (!fs.existsSync(dir)) throw new SyncError('HFS_SYNC_SKELETON_MISSING', `no skeleton templates in ${path.relative(TEMPLATES_DIR, dir)}`);
-    for (const rel of listFiles(dir)) {
-      const source = fs.readFileSync(path.join(dir, rel), 'utf8').replace(/\r\n/g, '\n');
-      const once = { family: hfs.project, project: hfs.project };
-      if (!rel.includes(APP_DIR)) {
-        files.push({ path: rel.split(FAMILY_DIR).join(hfs.project), content: render(source, once) });
-        continue;
-      }
-      for (const app of skeletonApps(hfs)) {
-        files.push({ path: rel.split(APP_DIR).join(app.name), content: render(source, { ...once, app: app.name, appPascal: pascal(app.name) }) });
-      }
-    }
-  }
-  return files;
-}
-
-/** Writes the skeleton under `root`, skipping every file that exists: { created, skipped } path lists. */
-export function initSkeleton(root, hfs) {
-  const created = [], skipped = [];
-  for (const file of skeletonFiles(hfs)) {
-    const target = path.join(root, file.path);
-    if (fs.existsSync(target)) {
-      skipped.push(file.path);
-      continue;
-    }
-    fs.mkdirSync(path.dirname(target), { recursive: true });
-    fs.writeFileSync(target, file.content);
-    created.push(file.path);
-  }
-  return { created, skipped };
-}

package/templates/be/gitignore

@@ -1,2 +0,0 @@
-{{> common/gitignore.base}}
-schema.gql

package/templates/be/hooks/husky/pre-commit

@@ -1,13 +0,0 @@
-{{header}}
-# Commit gate: the secrets guard and work hygiene of the staged files, types, lint and format of the staged files, the unit specs the staged files touch. Never integration, e2e or contract.
-npx hfs work-hygiene
-npm run typecheck
-sources=$(git diff --cached --name-only --diff-filter=ACMR -- '*.ts' '*.mts' '*.cts' '*.js' '*.mjs' '*.cjs' || true)
-if [ -n "$sources" ]; then
-  npx eslint $sources
-  npx prettier --check $sources
-fi
-specs=$(git diff --cached --name-only --diff-filter=ACMR -- '*.ts' | grep -v -E '(^|/)src/tests/(world|integration|e2e|contract)/|\.(integration|e2e|contract)-spec\.ts$' || true)
-if [ -n "$specs" ]; then
-  npm run test:affected -- --findRelatedTests $specs
-fi

package/templates/be/hooks/husky/pre-push

@@ -1,7 +0,0 @@
-{{header}}
-# Push gate: types, lint, format, the architecture check on the owners this push touches, unit specs affected since main. Never integration, e2e or contract.
-npm run typecheck
-npm run lint:check
-npm run format:check
-npm run hfs:check -- --fast
-npm run test:affected -- --changedSince=origin/main

package/templates/be/package-scripts/package.json

@@ -1,22 +0,0 @@
-{
-  "scripts": {
-    "build": "tsc -p tsconfig.build.json && tsc-alias -p tsconfig.build.json",
-    {{appScripts}}
-    "typecheck": "tsc -p tsconfig.json",
-    "typecheck:tests": "tsc -p src/tests/tsconfig.json",
-    "lint": "eslint --fix .",
-    "lint:check": "eslint .",
-    "lint:report": "eslint . --format json --output-file reports/eslint.json",
-    "format": "prettier --write .",
-    "format:check": "prettier --check .",
-    "test": "jest --selectProjects unit --coverage",
-    "test:affected": "jest --selectProjects unit --passWithNoTests",
-    "test:integration": "npm run typecheck:tests && jest --selectProjects integration",
-    "test:e2e": "npm run typecheck:tests && jest --selectProjects e2e",
-    "test:contract": "npm run typecheck:tests && jest --selectProjects contract",
-    "test:stack": "starci-test-stack",
-    "contract:emit": "hfs emit-contracts",
-    "hfs:check": "hfs check",
-    "hfs:report": "hfs check --sonar reports/hfs.sonar.json"
-  }
-}

package/templates/be/skeleton/src/modules/platform/config/config.decorators.ts

@@ -1,9 +0,0 @@
-import { injector } from "@modules/platform/composition"
-import type { TypedParameterDecorator } from "@modules/platform/composition"
-import type { ServerOptions } from "./server.options"
-
-/** Token under which the app module provides its {@link ServerOptions}. */
-export const SERVER_OPTIONS: unique symbol = Symbol("platform.config.server-options")
-
-/** Injects the server options of the app. Parameter type: ServerOptions. */
-export const InjectServerOptions = (): TypedParameterDecorator<ServerOptions> => injector<ServerOptions>(SERVER_OPTIONS)

package/templates/be/skeleton/src/modules/platform/errors/error.filter.ts

@@ -1,20 +0,0 @@
-import { Catch, HttpException, HttpStatus } from "@nestjs/common"
-import type { ArgumentsHost, ExceptionFilter } from "@nestjs/common"
-import type { Response } from "express"
-import { InjectLogger } from "@modules/platform/logging"
-import type { Logger } from "@modules/platform/logging"
-import { ErrorsLogEvent } from "./errors.log-events"
-
-@Catch()
-/** The one filter of an app: logs every failure once and answers with a status and a code that reveal nothing else. */
-export class ErrorFilter implements ExceptionFilter {
-    constructor(@InjectLogger() private readonly logger: Logger) {}
-
-    /** Answers the request; an unknown failure is a 500 whose body names no detail. */
-    catch(exception: unknown, host: ArgumentsHost): void {
-        const status = exception instanceof HttpException ? exception.getStatus() : HttpStatus.INTERNAL_SERVER_ERROR
-        this.logger.error(ErrorsLogEvent.RequestFailed, exception, { status })
-        const code = status === HttpStatus.INTERNAL_SERVER_ERROR ? "internal_error" : `http_${status}`
-        host.switchToHttp().getResponse<Response>().status(status).json({ code })
-    }
-}

package/templates/be/tool-config/prettierignore

@@ -1,8 +0,0 @@
-{{header}}
-dist/
-coverage/
-node_modules/
-package-lock.json
-contracts/
-.starcistacks/
-.starciwork/

package/templates/fe/ci-workflows/github/workflows/ci.yml

@@ -1,54 +0,0 @@
-{{header}}
-name: ci
-
-on:
-  push:
-    branches: [main]
-  pull_request:
-
-permissions:
-  contents: read
-
-jobs:
-  ci:
-    runs-on: ubuntu-latest
-    env:
-      SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
-    steps:
-      - uses: actions/checkout@v4
-      - uses: actions/setup-node@v4
-        with:
-          node-version: {{nodeMajor}}
-          cache: npm
-      - run: npm ci
-      - name: hfs check
-        run: npm run hfs:report
-      - name: lint
-        run: npm run lint:check
-      - name: eslint report
-        if: ${{ !cancelled() }}
-        run: npm run lint:report
-      - name: eslint sonar import
-        if: ${{ !cancelled() }}
-        run: npx hfs report eslint reports/eslint.json reports/eslint.sonar.json
-      - name: stylelint report
-        if: ${{ !cancelled() }}
-        run: npm run lint:report:css
-      - name: stylelint sonar import
-        if: ${{ !cancelled() }}
-        run: npx hfs report stylelint reports/stylelint.json reports/stylelint.sonar.json
-      - name: format
-        run: npm run format:check
-      - name: typecheck
-        run: npm run typecheck
-      - name: build
-        run: npm run build
-      - uses: SonarSource/sonarqube-scan-action@v7
-        if: ${{ !cancelled() && env.SONAR_TOKEN != '' }}
-        env:
-          SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}
-      - uses: SonarSource/sonarqube-quality-gate-action@v1
-        if: ${{ !cancelled() && env.SONAR_TOKEN != '' }}
-        timeout-minutes: 10
-        env:
-          SONAR_HOST_URL: ${{ vars.SONAR_HOST_URL }}

package/templates/fe/gitignore

@@ -1,3 +0,0 @@
-{{> common/gitignore.base}}
-.next/
-next-env.d.ts