Merge pull request #390 from Luca-Timo/feat/self-hosted-fonts
feat(branding): self-hosted webfonts with filesystem scanner
This commit is contained in:
Paul Nothaft
@@ -0,0 +1,293 @@
|
||||
const fs = require('fs');
|
||||
const fsPromises = fs.promises;
|
||||
const os = require('os');
|
||||
const path = require('path');
|
||||
|
||||
// Silence the logger so test output stays clean. Capture calls so the
|
||||
// "warning logged" assertions can still verify behaviour.
|
||||
jest.mock('../../src/utils/logger', () => ({
|
||||
warn: jest.fn(),
|
||||
info: jest.fn(),
|
||||
error: jest.fn(),
|
||||
debug: jest.fn()
|
||||
}));
|
||||
|
||||
const logger = require('../../src/utils/logger');
|
||||
|
||||
let bundledRoot;
|
||||
let userRoot;
|
||||
let fontsService;
|
||||
|
||||
/**
|
||||
* Create a font family folder with the given weights (and optional meta.json).
|
||||
* @param {string} root absolute path to the bundled or user root
|
||||
* @param {string} folderName e.g. "Inter" or "Playfair-Display"
|
||||
* @param {Array<number>|Array<string>} weights numeric weights (creates `<w>.woff2`)
|
||||
* or filenames to create directly
|
||||
* @param {Object|null} meta optional meta.json contents (object) or null
|
||||
*/
|
||||
async function makeFamily(root, folderName, weights, meta = null) {
|
||||
const dir = path.join(root, folderName);
|
||||
await fsPromises.mkdir(dir, { recursive: true });
|
||||
for (const w of weights) {
|
||||
const fname = typeof w === 'number' ? `${w}.woff2` : w;
|
||||
await fsPromises.writeFile(path.join(dir, fname), Buffer.from([]));
|
||||
}
|
||||
if (meta !== null) {
|
||||
await fsPromises.writeFile(
|
||||
path.join(dir, 'meta.json'),
|
||||
typeof meta === 'string' ? meta : JSON.stringify(meta)
|
||||
);
|
||||
}
|
||||
return dir;
|
||||
}
|
||||
|
||||
beforeEach(async () => {
|
||||
jest.clearAllMocks();
|
||||
|
||||
bundledRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'picpeak-fonts-bundled-'));
|
||||
userRoot = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'picpeak-fonts-user-'));
|
||||
|
||||
process.env.PICPEAK_BUNDLED_FONTS_ROOT = bundledRoot;
|
||||
// The user root resolves under STORAGE_PATH/fonts, so STORAGE_PATH must
|
||||
// point at the parent of userRoot — we name the leaf "fonts" ourselves.
|
||||
const storageParent = await fsPromises.mkdtemp(path.join(os.tmpdir(), 'picpeak-fonts-storage-'));
|
||||
await fsPromises.rename(userRoot, path.join(storageParent, 'fonts'));
|
||||
userRoot = path.join(storageParent, 'fonts');
|
||||
process.env.STORAGE_PATH = storageParent;
|
||||
|
||||
// Re-require fresh after env is set so module-level constants (none here,
|
||||
// but cache state is module-level) start clean.
|
||||
jest.resetModules();
|
||||
fontsService = require('../../src/services/fontsService');
|
||||
fontsService.clearFontsCache();
|
||||
});
|
||||
|
||||
afterEach(async () => {
|
||||
fontsService.clearFontsCache();
|
||||
await fsPromises.rm(bundledRoot, { recursive: true, force: true }).catch(() => {});
|
||||
// userRoot's parent is the actual mkdtemp; remove it.
|
||||
await fsPromises.rm(path.dirname(userRoot), { recursive: true, force: true }).catch(() => {});
|
||||
delete process.env.PICPEAK_BUNDLED_FONTS_ROOT;
|
||||
delete process.env.STORAGE_PATH;
|
||||
});
|
||||
|
||||
describe('fontsService.listFonts', () => {
|
||||
describe('roots', () => {
|
||||
test('empty bundled root + missing user root → []', async () => {
|
||||
// delete user root so it triggers ENOENT
|
||||
await fsPromises.rm(path.dirname(userRoot), { recursive: true, force: true });
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts).toEqual([]);
|
||||
});
|
||||
|
||||
test('missing bundled root (ENOENT) → [], does not throw', async () => {
|
||||
await fsPromises.rm(bundledRoot, { recursive: true, force: true });
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts).toEqual([]);
|
||||
});
|
||||
|
||||
test('non-directory entries at the root are skipped', async () => {
|
||||
await fsPromises.writeFile(path.join(bundledRoot, 'README.md'), 'hi');
|
||||
await makeFamily(bundledRoot, 'Inter', [400, 700]);
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts.map((f) => f.family)).toEqual(['Inter']);
|
||||
});
|
||||
|
||||
test('hidden folders are skipped', async () => {
|
||||
await makeFamily(bundledRoot, '.git', [400]);
|
||||
await makeFamily(bundledRoot, '.DS_Store', [400]);
|
||||
await makeFamily(bundledRoot, 'Inter', [400]);
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts.map((f) => f.family)).toEqual(['Inter']);
|
||||
});
|
||||
});
|
||||
|
||||
describe('weight parsing', () => {
|
||||
test('three weight files → sorted ascending', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [700, 400, 600]);
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.weights).toEqual([400, 600, 700]);
|
||||
});
|
||||
|
||||
test('non-numeric filenames are ignored', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', ['bold.woff2', 'regular.woff2', '400.woff2', '700.woff2']);
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.weights).toEqual([400, 700]);
|
||||
});
|
||||
|
||||
test('non-.woff2 files are ignored', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', ['400.ttf', '400.woff', '400.woff2', '700.otf']);
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.weights).toEqual([400]);
|
||||
});
|
||||
|
||||
test('weight values out of range (sub-1 / over-1000) are ignored', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [0, 400, 1001, 700]);
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.weights).toEqual([400, 700]);
|
||||
});
|
||||
|
||||
test('family folder with no usable .woff2 files is silently skipped', async () => {
|
||||
await makeFamily(bundledRoot, 'NoWeights', ['readme.txt', 'bold.ttf']);
|
||||
await makeFamily(bundledRoot, 'Inter', [400]);
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts.map((f) => f.family)).toEqual(['Inter']);
|
||||
expect(logger.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('Skipping NoWeights')
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('folder name → display family', () => {
|
||||
test('hyphens become spaces', async () => {
|
||||
await makeFamily(bundledRoot, 'Playfair-Display', [400]);
|
||||
const [pd] = await fontsService.listFonts();
|
||||
expect(pd.family).toBe('Playfair Display');
|
||||
});
|
||||
|
||||
test('case is preserved', async () => {
|
||||
await makeFamily(bundledRoot, 'IBM-Plex-Sans', [400]);
|
||||
const [ibm] = await fontsService.listFonts();
|
||||
expect(ibm.family).toBe('IBM Plex Sans');
|
||||
});
|
||||
});
|
||||
|
||||
describe('user-overrides-bundled', () => {
|
||||
test('user folder of the same family wins; weights come from user', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400, 600, 700]);
|
||||
await makeFamily(userRoot, 'Inter', [400, 900]); // different weights
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.weights).toEqual([400, 900]);
|
||||
expect(logger.info).toHaveBeenCalledWith(
|
||||
expect.stringContaining('overrides bundled default')
|
||||
);
|
||||
});
|
||||
|
||||
test('user-only family is included', async () => {
|
||||
await makeFamily(userRoot, 'Lobster', [400]);
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts.map((f) => f.family)).toEqual(['Lobster']);
|
||||
});
|
||||
|
||||
test('case-insensitive duplicate within the same root → second skipped, warning', async () => {
|
||||
// Two different folder names both producing the family "Inter".
|
||||
// On case-insensitive filesystems (APFS) this can't actually happen at
|
||||
// the FS layer; we simulate by using two different display names that
|
||||
// normalize identically. "Inter" and "INTER" lowercase to the same key.
|
||||
await makeFamily(bundledRoot, 'Inter', [400]);
|
||||
await makeFamily(bundledRoot, 'INTER', [700]);
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts).toHaveLength(1);
|
||||
expect(logger.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('Duplicate family')
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('meta.json — generic fallback', () => {
|
||||
test('valid generic="serif"', async () => {
|
||||
await makeFamily(bundledRoot, 'Playfair-Display', [400], { generic: 'serif' });
|
||||
const [pd] = await fontsService.listFonts();
|
||||
expect(pd.generic).toBe('serif');
|
||||
});
|
||||
|
||||
test('valid generic="cursive"', async () => {
|
||||
await makeFamily(bundledRoot, 'Comic-Neue', [400], { generic: 'cursive' });
|
||||
const [cn] = await fontsService.listFonts();
|
||||
expect(cn.generic).toBe('cursive');
|
||||
});
|
||||
|
||||
test('valid generic="monospace"', async () => {
|
||||
await makeFamily(bundledRoot, 'Fira-Mono', [400], { generic: 'monospace' });
|
||||
const [fm] = await fontsService.listFonts();
|
||||
expect(fm.generic).toBe('monospace');
|
||||
});
|
||||
|
||||
test('missing meta.json → defaults to sans-serif (no warning)', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400]);
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.generic).toBe('sans-serif');
|
||||
// No warning for the missing-file case (it's the normal path).
|
||||
const noisy = (logger.warn.mock.calls || []).filter((c) =>
|
||||
String(c[0]).includes('meta.json')
|
||||
);
|
||||
expect(noisy).toEqual([]);
|
||||
});
|
||||
|
||||
test('invalid generic value → defaults to sans-serif, warning logged', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400], { generic: 'bogus' });
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.generic).toBe('sans-serif');
|
||||
expect(logger.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('invalid generic "bogus"')
|
||||
);
|
||||
});
|
||||
|
||||
test('malformed JSON → defaults to sans-serif, warning logged', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400], '{ this is not json');
|
||||
const [inter] = await fontsService.listFonts();
|
||||
expect(inter.generic).toBe('sans-serif');
|
||||
expect(logger.warn).toHaveBeenCalledWith(
|
||||
expect.stringContaining('not valid JSON')
|
||||
);
|
||||
});
|
||||
});
|
||||
|
||||
describe('result shape', () => {
|
||||
test('every family is { family, weights, generic }', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400, 700]);
|
||||
await makeFamily(bundledRoot, 'Playfair-Display', [400], { generic: 'serif' });
|
||||
const fonts = await fontsService.listFonts();
|
||||
for (const f of fonts) {
|
||||
expect(f).toEqual({
|
||||
family: expect.any(String),
|
||||
weights: expect.any(Array),
|
||||
generic: expect.stringMatching(/^(sans-serif|serif|cursive|monospace)$/)
|
||||
});
|
||||
expect(f.weights.length).toBeGreaterThan(0);
|
||||
}
|
||||
});
|
||||
|
||||
test('output sorted alphabetically by family', async () => {
|
||||
await makeFamily(bundledRoot, 'Zilla-Slab', [400]);
|
||||
await makeFamily(bundledRoot, 'Alpha-Sans', [400]);
|
||||
await makeFamily(bundledRoot, 'Mid-Pack', [400]);
|
||||
const fonts = await fontsService.listFonts();
|
||||
expect(fonts.map((f) => f.family)).toEqual([
|
||||
'Alpha Sans',
|
||||
'Mid Pack',
|
||||
'Zilla Slab'
|
||||
]);
|
||||
});
|
||||
});
|
||||
|
||||
describe('cache', () => {
|
||||
test('cache hit: second call within TTL does not re-readdir', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400]);
|
||||
const spy = jest.spyOn(fsPromises, 'readdir');
|
||||
await fontsService.listFonts();
|
||||
const callsAfterFirst = spy.mock.calls.length;
|
||||
await fontsService.listFonts();
|
||||
expect(spy.mock.calls.length).toBe(callsAfterFirst);
|
||||
spy.mockRestore();
|
||||
});
|
||||
|
||||
test('clearFontsCache forces a fresh scan on the next call', async () => {
|
||||
await makeFamily(bundledRoot, 'Inter', [400]);
|
||||
await fontsService.listFonts();
|
||||
|
||||
// Add a new family AFTER the cache was populated.
|
||||
await makeFamily(bundledRoot, 'Roboto', [400]);
|
||||
|
||||
// Without clearing, listFonts returns the stale cache.
|
||||
const stale = await fontsService.listFonts();
|
||||
expect(stale.map((f) => f.family)).toEqual(['Inter']);
|
||||
|
||||
// After clear, the new family appears.
|
||||
fontsService.clearFontsCache();
|
||||
const fresh = await fontsService.listFonts();
|
||||
expect(fresh.map((f) => f.family)).toEqual(['Inter', 'Roboto']);
|
||||
});
|
||||
});
|
||||
});
|
||||
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,3 @@
|
||||
{
|
||||
"generic": "cursive"
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,114 @@
|
||||
This directory bundles the following typefaces, each licensed under the
|
||||
SIL Open Font License v1.1.
|
||||
------------------------------------------------------------
|
||||
Per-font copyright notices
|
||||
------------------------------------------------------------
|
||||
Inter
|
||||
Copyright (c) 2016 The Inter Project Authors (https://github.com/rsms/inter)
|
||||
Noto Sans
|
||||
Copyright 2022 The Noto Project Authors (https://github.com/notofonts/latin-greek-cyrillic)
|
||||
Poppins
|
||||
Copyright 2020 The Poppins Project Authors (https://github.com/itfoundry/Poppins)
|
||||
Jost
|
||||
Copyright 2020 The Jost Project Authors (https://github.com/indestructible-type/Jost)
|
||||
Montserrat
|
||||
Copyright 2011 The Montserrat Project Authors (https://github.com/JulietaUla/Montserrat)
|
||||
Playfair Display
|
||||
Copyright 2017 The Playfair Display Project Authors (https://github.com/clauseggers/Playfair)
|
||||
IBM Plex Sans
|
||||
Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
|
||||
Comic Neue
|
||||
Copyright (c) 2014 by Craig Rozynski. All rights reserved.
|
||||
|
||||
|
||||
This Font Software is licensed under the SIL Open Font License, Version 1.1.
|
||||
This license is copied below, and is also available with a FAQ at:
|
||||
https://openfontlicense.org
|
||||
|
||||
|
||||
-----------------------------------------------------------
|
||||
SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
|
||||
-----------------------------------------------------------
|
||||
|
||||
PREAMBLE
|
||||
The goals of the Open Font License (OFL) are to stimulate worldwide
|
||||
development of collaborative font projects, to support the font creation
|
||||
efforts of academic and linguistic communities, and to provide a free and
|
||||
open framework in which fonts may be shared and improved in partnership
|
||||
with others.
|
||||
|
||||
The OFL allows the licensed fonts to be used, studied, modified and
|
||||
redistributed freely as long as they are not sold by themselves. The
|
||||
fonts, including any derivative works, can be bundled, embedded,
|
||||
redistributed and/or sold with any software provided that any reserved
|
||||
names are not used by derivative works. The fonts and derivatives,
|
||||
however, cannot be released under any other type of license. The
|
||||
requirement for fonts to remain under this license does not apply
|
||||
to any document created using the fonts or their derivatives.
|
||||
|
||||
DEFINITIONS
|
||||
"Font Software" refers to the set of files released by the Copyright
|
||||
Holder(s) under this license and clearly marked as such. This may
|
||||
include source files, build scripts and documentation.
|
||||
|
||||
"Reserved Font Name" refers to any names specified as such after the
|
||||
copyright statement(s).
|
||||
|
||||
"Original Version" refers to the collection of Font Software components as
|
||||
distributed by the Copyright Holder(s).
|
||||
|
||||
"Modified Version" refers to any derivative made by adding to, deleting,
|
||||
or substituting -- in part or in whole -- any of the components of the
|
||||
Original Version, by changing formats or by porting the Font Software to a
|
||||
new environment.
|
||||
|
||||
"Author" refers to any designer, engineer, programmer, technical
|
||||
writer or other person who contributed to the Font Software.
|
||||
|
||||
PERMISSION & CONDITIONS
|
||||
Permission is hereby granted, free of charge, to any person obtaining
|
||||
a copy of the Font Software, to use, study, copy, merge, embed, modify,
|
||||
redistribute, and sell modified and unmodified copies of the Font
|
||||
Software, subject to the following conditions:
|
||||
|
||||
1) Neither the Font Software nor any of its individual components,
|
||||
in Original or Modified Versions, may be sold by itself.
|
||||
|
||||
2) Original or Modified Versions of the Font Software may be bundled,
|
||||
redistributed and/or sold with any software, provided that each copy
|
||||
contains the above copyright notice and this license. These can be
|
||||
included either as stand-alone text files, human-readable headers or
|
||||
in the appropriate machine-readable metadata fields within text or
|
||||
binary files as long as those fields can be easily viewed by the user.
|
||||
|
||||
3) No Modified Version of the Font Software may use the Reserved Font
|
||||
Name(s) unless explicit written permission is granted by the corresponding
|
||||
Copyright Holder. This restriction only applies to the primary font name as
|
||||
presented to the users.
|
||||
|
||||
4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
|
||||
Software shall not be used to promote, endorse or advertise any
|
||||
Modified Version, except to acknowledge the contribution(s) of the
|
||||
Copyright Holder(s) and the Author(s) or with their explicit written
|
||||
permission.
|
||||
|
||||
5) The Font Software, modified or unmodified, in part or in whole,
|
||||
must be distributed entirely under this license, and must not be
|
||||
distributed under any other license. The requirement for fonts to
|
||||
remain under this license does not apply to any document created
|
||||
using the Font Software.
|
||||
|
||||
TERMINATION
|
||||
This license becomes null and void if any of the above conditions are
|
||||
not met.
|
||||
|
||||
DISCLAIMER
|
||||
THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
||||
EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
|
||||
MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
|
||||
OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
|
||||
COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
|
||||
INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
|
||||
DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
|
||||
FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
|
||||
OTHER DEALINGS IN THE FONT SOFTWARE.
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -0,0 +1,3 @@
|
||||
{
|
||||
"generic": "serif"
|
||||
}
|
||||
Binary file not shown.
Binary file not shown.
Binary file not shown.
@@ -449,6 +449,34 @@ app.use('/thumbnails', require('./src/middleware/photoAuth'), setCorsHeaders, se
|
||||
// Static file serving for uploads (public - logos, favicons)
|
||||
app.use('/uploads', setCorsHeaders, secureStatic(path.join(storagePath, 'uploads')));
|
||||
|
||||
// Static file serving for self-hosted webfonts (public — gallery visitors
|
||||
// load these via @font-face). Replaces the previous Google Fonts CDN
|
||||
// dependency, which leaked visitor IPs to a third party (LG München 2022
|
||||
// GDPR ruling).
|
||||
//
|
||||
// Two mounts in priority order:
|
||||
// 1. STORAGE_PATH/fonts/ — runtime user additions (drop a folder, restart)
|
||||
// 2. backend/assets/fonts/ — bundled defaults baked into the image
|
||||
// Express evaluates handlers in order, so user-supplied files win on overlap.
|
||||
//
|
||||
// We deliberately do NOT set `immutable` on these responses. The filenames
|
||||
// are stable (e.g. Inter/400.woff2), so an admin replacing the file on disk
|
||||
// must be able to roll out the change to clients. With max-age + Last-Modified
|
||||
// (set by express.static from file mtime), browsers send If-Modified-Since
|
||||
// after expiry and pick up the new version automatically. See docs/fonts.md
|
||||
// "Replacing an existing font" for the documented rollout strategy.
|
||||
const fontStaticOpts = { maxAge: '7d' };
|
||||
app.use(
|
||||
'/fonts',
|
||||
setCorsHeaders,
|
||||
secureStatic(path.join(storagePath, 'fonts'), fontStaticOpts)
|
||||
);
|
||||
app.use(
|
||||
'/fonts',
|
||||
setCorsHeaders,
|
||||
secureStatic(path.resolve(__dirname, 'assets/fonts'), fontStaticOpts)
|
||||
);
|
||||
|
||||
// Debug endpoint to check IP detection (only in development)
|
||||
if (process.env.NODE_ENV === 'development') {
|
||||
app.get('/api/debug/ip', (req, res) => {
|
||||
@@ -563,6 +591,7 @@ app.use('/api/v1', require('./src/routes/v1/events'));
|
||||
|
||||
app.use('/api/invite', require('./src/routes/acceptInvite'));
|
||||
app.use('/api/public/settings', require('./src/routes/publicSettings'));
|
||||
app.use('/api/public/fonts', require('./src/routes/publicFonts'));
|
||||
app.use('/api/public', require('./src/routes/publicCMS'));
|
||||
app.use('/api/images', require('./src/routes/protectedImages'));
|
||||
app.use('/api/secure-images', secureImagesRoutes);
|
||||
|
||||
@@ -0,0 +1,24 @@
|
||||
const express = require('express');
|
||||
const { listFonts } = require('../services/fontsService');
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
const router = express.Router();
|
||||
|
||||
/**
|
||||
* GET /api/public/fonts
|
||||
*
|
||||
* Returns the list of self-hosted font families discovered under
|
||||
* STORAGE_PATH/fonts/. No authentication — gallery visitors need this
|
||||
* to render the chosen theme font.
|
||||
*/
|
||||
router.get('/', async (req, res) => {
|
||||
try {
|
||||
const fonts = await listFonts();
|
||||
res.json({ fonts });
|
||||
} catch (error) {
|
||||
logger.error('Failed to list fonts', { error: error.message });
|
||||
res.status(500).json({ error: 'Failed to list fonts' });
|
||||
}
|
||||
});
|
||||
|
||||
module.exports = router;
|
||||
@@ -0,0 +1,223 @@
|
||||
const fs = require('fs').promises;
|
||||
const path = require('path');
|
||||
const logger = require('../utils/logger');
|
||||
|
||||
/**
|
||||
* Filesystem-driven font scanner.
|
||||
*
|
||||
* Scans two locations for self-hosted webfonts and merges the results:
|
||||
*
|
||||
* 1. backend/assets/fonts/ — bundled defaults shipped with the repo
|
||||
* and baked into the Docker image. Visitors get a working font
|
||||
* picker out of the box, no external CDN, no GDPR exposure.
|
||||
*
|
||||
* 2. STORAGE_PATH/fonts/ — optional runtime additions. Admins drop
|
||||
* a folder here (via Docker volume / SFTP) and the family appears
|
||||
* in the picker after the cache TTL expires or the backend restarts.
|
||||
* User additions WIN over bundled defaults of the same family name —
|
||||
* this lets a deployment override e.g. with extra weights or a newer
|
||||
* version without forking the repo.
|
||||
*
|
||||
* Folder layout in either location:
|
||||
*
|
||||
* <Family-Name>/<weight>.woff2
|
||||
* <Family-Name>/meta.json (optional)
|
||||
*
|
||||
* - Folder name → display family with hyphens replaced by spaces:
|
||||
* "Playfair-Display" → "Playfair Display"
|
||||
* - Weight files must be named "<integer>.woff2" (e.g. 400.woff2).
|
||||
* Other names are ignored, family entry still includes its other weights.
|
||||
* - Optional meta.json: { "generic": "sans-serif" | "serif" | "cursive" | "monospace" }
|
||||
* Tells the picker which CSS generic family to use as a fallback when
|
||||
* building the font-family string. Defaults to "sans-serif" if absent
|
||||
* or invalid. Avoids hardcoding family-name → generic lookups in the
|
||||
* frontend, so any new family folder works without code changes.
|
||||
*
|
||||
* Result is cached in memory for FONTS_CACHE_TTL_MS so frequent
|
||||
* /api/public/fonts hits don't hit disk per request. New folders dropped
|
||||
* into a mount become visible after the TTL or on backend restart.
|
||||
*
|
||||
* Pattern mirrors backend/src/services/uploadSettings.js.
|
||||
*/
|
||||
|
||||
const FONTS_CACHE_TTL_MS = 30_000;
|
||||
const VALID_GENERICS = new Set(['sans-serif', 'serif', 'cursive', 'monospace']);
|
||||
const DEFAULT_GENERIC = 'sans-serif';
|
||||
|
||||
let cachedFonts = null;
|
||||
let fontsCacheExpiresAt = 0;
|
||||
|
||||
function getBundledFontsRoot() {
|
||||
// Test seam: the unit test suite points this at an isolated temp dir so it
|
||||
// can populate fixtures without polluting the real backend/assets tree.
|
||||
if (process.env.PICPEAK_BUNDLED_FONTS_ROOT) {
|
||||
return process.env.PICPEAK_BUNDLED_FONTS_ROOT;
|
||||
}
|
||||
// backend/src/services/fontsService.js → backend/assets/fonts
|
||||
return path.resolve(__dirname, '../../assets/fonts');
|
||||
}
|
||||
|
||||
function getUserFontsRoot() {
|
||||
const storagePath = process.env.STORAGE_PATH || path.join(__dirname, '../../../storage');
|
||||
return path.join(storagePath, 'fonts');
|
||||
}
|
||||
|
||||
function familyDisplayName(folderName) {
|
||||
return folderName.replace(/-/g, ' ');
|
||||
}
|
||||
|
||||
/**
|
||||
* Try to read meta.json from the family folder. Returns the validated
|
||||
* generic class or DEFAULT_GENERIC. Missing file → silent default.
|
||||
* Unreadable / malformed / invalid value → warning + default.
|
||||
*/
|
||||
async function readFamilyMeta(folderAbs, folderName) {
|
||||
const metaPath = path.join(folderAbs, 'meta.json');
|
||||
let raw;
|
||||
try {
|
||||
raw = await fs.readFile(metaPath, 'utf8');
|
||||
} catch (err) {
|
||||
if (err.code === 'ENOENT') return DEFAULT_GENERIC;
|
||||
logger.warn(`[fonts] Could not read meta.json for ${folderName}: ${err.message}`);
|
||||
return DEFAULT_GENERIC;
|
||||
}
|
||||
|
||||
let parsed;
|
||||
try {
|
||||
parsed = JSON.parse(raw);
|
||||
} catch (err) {
|
||||
logger.warn(`[fonts] meta.json for ${folderName} is not valid JSON: ${err.message}`);
|
||||
return DEFAULT_GENERIC;
|
||||
}
|
||||
|
||||
const generic = parsed && typeof parsed.generic === 'string' ? parsed.generic : null;
|
||||
if (generic && VALID_GENERICS.has(generic)) {
|
||||
return generic;
|
||||
}
|
||||
if (generic) {
|
||||
logger.warn(
|
||||
`[fonts] meta.json for ${folderName} has invalid generic "${generic}"; ` +
|
||||
`expected one of ${Array.from(VALID_GENERICS).join(', ')}. Falling back to ${DEFAULT_GENERIC}.`
|
||||
);
|
||||
}
|
||||
return DEFAULT_GENERIC;
|
||||
}
|
||||
|
||||
/**
|
||||
* Read one family folder and return { family, weights, generic } or null
|
||||
* if the folder has no usable .woff2 files.
|
||||
*/
|
||||
async function readFamilyFolder(rootAbs, folderName) {
|
||||
const folderAbs = path.join(rootAbs, folderName);
|
||||
let entries;
|
||||
try {
|
||||
entries = await fs.readdir(folderAbs, { withFileTypes: true });
|
||||
} catch (err) {
|
||||
logger.warn(`[fonts] Could not read family folder ${folderName} in ${rootAbs}: ${err.message}`);
|
||||
return null;
|
||||
}
|
||||
|
||||
const weights = [];
|
||||
for (const entry of entries) {
|
||||
if (!entry.isFile()) continue;
|
||||
if (!entry.name.toLowerCase().endsWith('.woff2')) continue;
|
||||
const stem = entry.name.slice(0, -'.woff2'.length);
|
||||
if (!/^\d+$/.test(stem)) continue; // ignore non-numeric weight names
|
||||
const weight = parseInt(stem, 10);
|
||||
if (weight < 1 || weight > 1000) continue;
|
||||
weights.push(weight);
|
||||
}
|
||||
|
||||
if (weights.length === 0) {
|
||||
logger.warn(`[fonts] Skipping ${folderName} in ${rootAbs}: no usable <weight>.woff2 files`);
|
||||
return null;
|
||||
}
|
||||
|
||||
weights.sort((a, b) => a - b);
|
||||
const generic = await readFamilyMeta(folderAbs, folderName);
|
||||
return { family: familyDisplayName(folderName), weights, generic };
|
||||
}
|
||||
|
||||
/**
|
||||
* Scan one root directory and return its families as a Map keyed by
|
||||
* lowercased family name (for case-insensitive de-dup against the other
|
||||
* root). Missing directory → empty Map (not an error).
|
||||
*/
|
||||
async function scanRoot(rootAbs) {
|
||||
let entries;
|
||||
try {
|
||||
entries = await fs.readdir(rootAbs, { withFileTypes: true });
|
||||
} catch (err) {
|
||||
if (err.code === 'ENOENT') {
|
||||
return new Map();
|
||||
}
|
||||
throw err;
|
||||
}
|
||||
|
||||
const result = new Map();
|
||||
for (const entry of entries) {
|
||||
if (!entry.isDirectory()) continue;
|
||||
if (entry.name.startsWith('.')) continue;
|
||||
|
||||
const family = await readFamilyFolder(rootAbs, entry.name);
|
||||
if (!family) continue;
|
||||
|
||||
const lc = family.family.toLowerCase();
|
||||
if (result.has(lc)) {
|
||||
logger.warn(
|
||||
`[fonts] Duplicate family ${family.family} within ${rootAbs}; ` +
|
||||
`keeping the first encountered folder`
|
||||
);
|
||||
continue;
|
||||
}
|
||||
result.set(lc, family);
|
||||
}
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
/**
|
||||
* List all available font families (bundled + user additions, merged).
|
||||
* Cached for FONTS_CACHE_TTL_MS.
|
||||
*
|
||||
* @returns {Promise<Array<{ family: string, weights: number[], generic: string }>>}
|
||||
*/
|
||||
async function listFonts() {
|
||||
if (Date.now() < fontsCacheExpiresAt && cachedFonts !== null) {
|
||||
return cachedFonts;
|
||||
}
|
||||
|
||||
const bundled = await scanRoot(getBundledFontsRoot());
|
||||
const userAdded = await scanRoot(getUserFontsRoot());
|
||||
|
||||
// User additions override bundled families of the same name.
|
||||
const merged = new Map(bundled);
|
||||
for (const [lc, family] of userAdded) {
|
||||
if (merged.has(lc)) {
|
||||
logger.info(
|
||||
`[fonts] User-supplied ${family.family} overrides bundled default`
|
||||
);
|
||||
}
|
||||
merged.set(lc, family);
|
||||
}
|
||||
|
||||
const families = Array.from(merged.values()).sort((a, b) =>
|
||||
a.family.localeCompare(b.family)
|
||||
);
|
||||
|
||||
cachedFonts = families;
|
||||
fontsCacheExpiresAt = Date.now() + FONTS_CACHE_TTL_MS;
|
||||
return cachedFonts;
|
||||
}
|
||||
|
||||
function clearFontsCache() {
|
||||
cachedFonts = null;
|
||||
fontsCacheExpiresAt = 0;
|
||||
}
|
||||
|
||||
module.exports = {
|
||||
listFonts,
|
||||
clearFontsCache,
|
||||
getBundledFontsRoot,
|
||||
getUserFontsRoot
|
||||
};
|
||||
Reference in New Issue
Block a user