ramdb2-cli 2.0.0-alpha.0 → 2.0.0-alpha.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/CHANGELOG.md ADDED
@@ -0,0 +1,7 @@
1
+ # ramdb2-cli
2
+
3
+ ## 2.0.0-alpha.1
4
+
5
+ ### Minor Changes
6
+
7
+ - 14d1f42: `ramdb2-cli infra build`: the Docker files of each server from `infra.yaml`, a front nginx with HTTPS and one domain per site, the API, its backups and the web site of each ramdb2 project.
package/README.md CHANGED
@@ -357,6 +357,65 @@ each list relation to check; write an `@onDelete` where the policy is not the de
357
357
 
358
358
  ---
359
359
 
360
+ ## infra
361
+
362
+ The servers of your sites, in Docker: one front nginx per server (HTTPS, one domain per site), and for each ramdb2
363
+ site its API, its backups and its web site. Only Docker is needed on the server: the images are built there, from
364
+ your machine, with `DOCKER_HOST=ssh://`.
365
+
366
+ ```sh
367
+ ramdb2-cli infra build # build/<server>/ for every server of ./infra.yaml
368
+ ramdb2-cli infra build ovh1 # one server
369
+ ```
370
+
371
+ An infra folder (a git repository of its own):
372
+
373
+ | Path | Content |
374
+ |---|---|
375
+ | `infra.yaml` | the backups, the servers and their sites |
376
+ | `custom/<name>.nginx.conf`, `custom/<name>.compose.yaml` | a site that is not a ramdb2 project, written by hand |
377
+ | `build/` | generated, rewritten by each build: keep it out of git |
378
+
379
+ ```yaml
380
+ backup:
381
+ target: sftp://backup@backups.example.org:22/ramdb2 # one folder per site under it
382
+ servers:
383
+ ovh1:
384
+ host: ssh://manu@ovh1.example.org
385
+ email: me@example.org # the Let's Encrypt account
386
+ sites:
387
+ ilife: # unique on all the servers: containers, volume, backup folder
388
+ source: ../ilife # the project, made by ramdb2-cli new, relative to infra.yaml
389
+ domain: ilife.fr
390
+ aliases: [www.ilife.fr] # redirected (301) to domain
391
+ memory: 512m
392
+ custom:
393
+ - gancio # custom/gancio.nginx.conf, and custom/gancio.compose.yaml if any
394
+ - name: wiki
395
+ domains: [wiki.example.org] # certbot keeps a certificate, in /etc/nginx/certs/wiki.example.org/
396
+ ```
397
+
398
+ All the errors of `infra.yaml` are reported at once. `build/<server>/` holds:
399
+
400
+ | File | Content |
401
+ |---|---|
402
+ | `compose.yaml` | the Compose project of the server, the custom compose files included |
403
+ | `nginx/` | the front nginx image: its configuration, one file per site, the custom ones copied |
404
+ | `<site>/api.Dockerfile` | the API (target `api`, `node src/index.js`) and its backups (target `backup`, `ramdb2-server-backup schedule`) |
405
+ | `<site>/web.Dockerfile` | for a project made with `--with-client`: the site compiled by Vite, served by nginx |
406
+ | `certificates.json` | the certificates of the server and their domains |
407
+
408
+ - Each domain: HTTP redirected to HTTPS, `/graphql` to the API, the rest to the web site (all to the API for a
409
+ project without a web site).
410
+ - The database lives in a Docker volume, `<site>-data`. The images never contain `node_modules` from your machine,
411
+ a database, a backup or a `.env`.
412
+ - Nothing is mounted from your machine: the nginx configuration is in its image; the secrets come from the
413
+ environment of `docker compose` (`RAMDB2_SECRETS`, the folder of the site `.env` files, and `BACKUP_SSH_KEY`).
414
+ - The healthcheck of the API sends the GraphQL query `health`: keep it open without a login.
415
+ - Until a certificate exists, nginx serves a self-signed one, so that it can start.
416
+
417
+ ---
418
+
360
419
  ## Programmatic use
361
420
 
362
421
  ```js
package/package.json CHANGED
@@ -1,11 +1,11 @@
1
1
  {
2
2
  "name": "ramdb2-cli",
3
- "version": "2.0.0-alpha.0",
3
+ "version": "2.0.0-alpha.1",
4
4
  "description": "Code generator and project scaffolding for ramdb2 and ramdb2-server",
5
5
  "type": "module",
6
6
  "exports": "./src/index.js",
7
7
  "bin": {
8
- "ramdb2-cli": "./src/cli.js"
8
+ "ramdb2-cli": "src/cli.js"
9
9
  },
10
10
  "license": "MIT",
11
11
  "author": "Emmanuel Leparquier",
@@ -23,11 +23,12 @@
23
23
  "test": "node --test \"test/**/*.test.js\""
24
24
  },
25
25
  "dependencies": {
26
- "graphql": "^16.14.2"
26
+ "graphql": "^16.14.2",
27
+ "yaml": "^2.9.1"
27
28
  },
28
29
  "devDependencies": {
29
- "ramdb2-core": "^2.0.0-alpha.0",
30
30
  "@vitejs/plugin-vue": "^6.0.10",
31
+ "ramdb2-core": "^2.0.0-alpha.1",
31
32
  "vite": "^8.3.5",
32
33
  "vue": "^3.5.44",
33
34
  "vue-router": "^5.4.0"
package/src/cli.js CHANGED
@@ -6,6 +6,8 @@ import { convert } from './convert.js'
6
6
  import { newProject } from './new.js'
7
7
  import { plantuml } from './plantuml.js'
8
8
  import { query } from './query.js'
9
+ import { readInfra } from './infra/config.js'
10
+ import { buildInfra } from './infra/build.js'
9
11
 
10
12
  const HELP = `ramdb2-cli: code generator of ramdb2
11
13
 
@@ -35,11 +37,23 @@ const HELP = `ramdb2-cli: code generator of ramdb2
35
37
  --packages: the packages folder of a ramdb2 repository, to depend on it through file: paths
36
38
  (default: the packages from npm, at the version of this ramdb2-cli).
37
39
 
40
+ ramdb2-cli infra build [<server>...] [--config <infra.yaml>]
41
+ Writes build/<server>/ next to infra.yaml (all the servers by default): compose.yaml, the front nginx,
42
+ the Dockerfiles of each site. Generated, rewritten each time: keep build/ out of git.
43
+
38
44
  ramdb2-cli convert --input <v1 preTypeDefs> --output <v2 preTypeDefs> [--force]
39
45
  Converts the v1 annotations ([PERSISTENT], [GROUP=], [FIELD=]) into directives, in a new file.
40
46
  `
41
47
 
42
48
  const commands = {
49
+ infra(values, [action, ...servers]) {
50
+ if (action !== 'build') return usage('infra needs an action: build')
51
+ const infra = readInfra(values.config ?? 'infra.yaml')
52
+ for (const { server, files } of buildInfra(infra, servers)) {
53
+ console.log(`${server}: ${files.length} files`)
54
+ for (const path of files) console.log(`written ${path}`)
55
+ }
56
+ },
43
57
  new(values, [dir]) {
44
58
  if (dir === undefined) return usage('new needs the folder of the project')
45
59
  const withClient = values['with-client'] ?? false
@@ -107,6 +121,7 @@ const { values, positionals } = parseArgs({
107
121
  'with-client': { type: 'boolean' },
108
122
  variables: { type: 'string' },
109
123
  file: { type: 'string' },
124
+ config: { type: 'string' },
110
125
  help: { type: 'boolean', short: 'h' },
111
126
  },
112
127
  })
@@ -118,7 +133,7 @@ if (values.help || command === undefined) {
118
133
  try {
119
134
  await command(values, positionals.slice(1))
120
135
  } catch (error) {
121
- console.error(error.name === 'SchemaError' || error.message.startsWith('No profile') ? error.message : error)
136
+ console.error(['SchemaError', 'InfraError'].includes(error.name) || error.message.startsWith('No profile') ? error.message : error)
122
137
  process.exitCode = 1
123
138
  }
124
139
  }
package/src/index.js CHANGED
@@ -6,3 +6,5 @@ export { query, expiryOf } from './query.js'
6
6
  export { readSchema, SchemaError } from './model.js'
7
7
  export { DIRECTIVES } from './directives.js'
8
8
  export { operationNames } from './generate/operations.js'
9
+ export { readInfra, InfraError } from './infra/config.js'
10
+ export { buildInfra, serverFiles, certificates } from './infra/build.js'
@@ -0,0 +1,372 @@
1
+ // ramdb2-cli infra build (D55): the files of each server, in build/<server>/, from infra.yaml.
2
+ // Nothing is mounted from the deployment machine (DOCKER_HOST=ssh://): what comes from it goes through a build
3
+ // context (nginx configuration, Dockerfiles) or the environment of docker compose (secrets).
4
+ import { copyFileSync, mkdirSync, rmSync, writeFileSync } from 'node:fs'
5
+ import { join, relative } from 'node:path'
6
+ import { stringify } from 'yaml'
7
+
8
+ const HEADER = 'Generated by ramdb2-cli infra build from infra.yaml: do not edit, it is rewritten.'
9
+ const LOGGING = { driver: 'local', options: { 'max-size': '10m', 'max-file': '5' } }
10
+ const API_PORT = 4000
11
+
12
+ /**
13
+ * Writes build/<server>/ for each server (or for the given ones), replacing what was there.
14
+ * @param {import('./config.js').Infra} infra
15
+ * @param {string[]} [only] server names
16
+ * @returns {{server: string, dir: string, files: string[]}[]}
17
+ */
18
+ export function buildInfra(infra, only) {
19
+ const servers = only === undefined || only.length === 0 ? infra.servers : only.map(name => {
20
+ const server = infra.servers.find(candidate => candidate.name === name)
21
+ if (server === undefined) throw new Error(`No server ${name} in infra.yaml`)
22
+ return server
23
+ })
24
+ return servers.map(server => {
25
+ const dir = join(infra.dir, 'build', server.name)
26
+ rmSync(dir, { recursive: true, force: true })
27
+ const files = []
28
+ const write = (path, content) => {
29
+ const file = join(dir, path)
30
+ mkdirSync(join(file, '..'), { recursive: true })
31
+ writeFileSync(file, content, path.endsWith('.sh') ? { mode: 0o755 } : undefined)
32
+ files.push(file)
33
+ }
34
+ for (const [path, content] of Object.entries(serverFiles(infra, server, dir))) write(path, content)
35
+ for (const custom of server.custom) {
36
+ const file = join(dir, 'nginx', 'conf.d', `50-custom-${custom.name}.conf`)
37
+ copyFileSync(custom.nginx, file)
38
+ files.push(file)
39
+ }
40
+ return { server: server.name, dir, files }
41
+ })
42
+ }
43
+
44
+ /**
45
+ * The generated files of one server, by path in build/<server>/ (the custom nginx files are copied apart).
46
+ * @param {import('./config.js').Infra} infra
47
+ * @param {import('./config.js').Server} server
48
+ * @param {string} dir build/<server>/
49
+ * @returns {Record<string, string>}
50
+ */
51
+ export function serverFiles(infra, server, dir) {
52
+ const files = {
53
+ 'compose.yaml': compose(infra, server, dir),
54
+ 'certificates.json': JSON.stringify(certificates(server), null, 2) + '\n',
55
+ 'nginx/Dockerfile': FRONT_DOCKERFILE,
56
+ 'nginx/ramdb2-certs.sh': CERTS_SCRIPT,
57
+ 'nginx/certificates': certificates(server).map(certificate => certificate.name).join('\n') + '\n',
58
+ 'nginx/conf.d/00-ramdb2.conf': FRONT_DEFAULTS,
59
+ }
60
+ for (const site of server.sites) {
61
+ files[`nginx/conf.d/10-${site.name}.conf`] = siteNginx(site)
62
+ files[`${site.name}/api.Dockerfile`] = apiDockerfile(site)
63
+ files[`${site.name}/api.Dockerfile.dockerignore`] = DOCKERIGNORE
64
+ if (site.withClient) {
65
+ files[`${site.name}/web.Dockerfile`] = WEB_DOCKERFILE
66
+ files[`${site.name}/web.Dockerfile.dockerignore`] = DOCKERIGNORE
67
+ files[`${site.name}/web.nginx.conf`] = WEB_NGINX
68
+ }
69
+ }
70
+ return files
71
+ }
72
+
73
+ /**
74
+ * The certificates of a server: one per ramdb2 site (its domain and aliases), one per custom site with domains.
75
+ * The certificate is named after its first domain, its folder in /etc/letsencrypt/live/ and /etc/nginx/certs/.
76
+ * @param {import('./config.js').Server} server
77
+ * @returns {{name: string, domains: string[]}[]}
78
+ */
79
+ export function certificates(server) {
80
+ return [
81
+ ...server.sites.map(site => ({ name: site.domain, domains: [site.domain, ...site.aliases] })),
82
+ ...server.custom.filter(custom => custom.domains.length > 0).map(custom => ({ name: custom.domains[0], domains: custom.domains })),
83
+ ]
84
+ }
85
+
86
+ function compose(infra, server, dir) {
87
+ const services = {
88
+ nginx: {
89
+ build: './nginx',
90
+ ports: ['80:80', '443:443'],
91
+ volumes: ['letsencrypt:/etc/letsencrypt:ro', 'certbot-www:/var/www/certbot:ro'],
92
+ restart: 'unless-stopped',
93
+ logging: LOGGING,
94
+ },
95
+ certbot: {
96
+ image: 'certbot/certbot',
97
+ entrypoint: ['/bin/sh', '-c',
98
+ 'trap exit TERM; while :; do certbot renew --webroot -w /var/www/certbot --quiet; sleep 12h & wait $${!}; done'],
99
+ volumes: ['letsencrypt:/etc/letsencrypt', 'certbot-www:/var/www/certbot'],
100
+ restart: 'unless-stopped',
101
+ logging: LOGGING,
102
+ },
103
+ }
104
+ const volumes = { letsencrypt: {}, 'certbot-www': {} }
105
+ for (const site of server.sites) {
106
+ const context = relative(dir, site.source) || '.'
107
+ const dockerfile = join(dir, site.name, 'api.Dockerfile')
108
+ const database = `/data/${site.name}.db`
109
+ services[`${site.name}-api`] = {
110
+ build: { context, dockerfile, target: 'api' },
111
+ env_file: [`\${RAMDB2_SECRETS:?run ramdb2-cli infra deploy}/${site.name}.env`],
112
+ environment: { PORT: String(API_PORT), DB_PATH: database, NODE_ENV: 'production', TRUST_PROXY: '1' },
113
+ volumes: [`${site.name}-data:/data`],
114
+ ...(site.memory === undefined ? {} : { mem_limit: site.memory }),
115
+ stop_grace_period: '30s',
116
+ healthcheck: {
117
+ test: ['CMD', 'node', '-e', HEALTH_CHECK],
118
+ interval: '30s',
119
+ timeout: '5s',
120
+ retries: 3,
121
+ start_period: '60s',
122
+ },
123
+ restart: 'unless-stopped',
124
+ logging: LOGGING,
125
+ }
126
+ services[`${site.name}-backup`] = {
127
+ build: { context, dockerfile, target: 'backup' },
128
+ environment: {
129
+ DB_PATH: database,
130
+ BACKUP_TARGET: infra.backup.target,
131
+ BACKUP_SITE: site.name,
132
+ BACKUP_SSH_KEY: '${BACKUP_SSH_KEY:?run ramdb2-cli infra deploy}',
133
+ },
134
+ volumes: [`${site.name}-data:/data`],
135
+ stop_grace_period: '2m',
136
+ restart: 'unless-stopped',
137
+ logging: LOGGING,
138
+ }
139
+ if (site.withClient) {
140
+ services[`${site.name}-web`] = {
141
+ build: {
142
+ context,
143
+ dockerfile: join(dir, site.name, 'web.Dockerfile'),
144
+ additional_contexts: { infra: `./${site.name}` },
145
+ },
146
+ restart: 'unless-stopped',
147
+ logging: LOGGING,
148
+ }
149
+ }
150
+ volumes[`${site.name}-data`] = {}
151
+ }
152
+ const include = server.custom.filter(custom => custom.compose !== undefined).map(custom => relative(dir, custom.compose))
153
+ const document = { name: server.name, ...(include.length > 0 ? { include } : {}), services, volumes }
154
+ return `# ${HEADER}\n# Server ${server.name}: deploy with ramdb2-cli infra deploy ${server.name}\n`
155
+ + stringify(document, { lineWidth: 0, aliasDuplicateObjects: false })
156
+ }
157
+
158
+ // The GraphQL query health of the project (ramdb2-cli new), answered by the API itself
159
+ const HEALTH_CHECK = `fetch('http://127.0.0.1:${API_PORT}/', { method: 'POST', headers: { 'content-type': 'application/json' }, `
160
+ + `body: '{"query":"{ health }"}' }).then(response => response.json())`
161
+ + `.then(body => process.exit(body.data?.health?.open ? 0 : 1), () => process.exit(1))`
162
+
163
+ function siteNginx(site) {
164
+ const cert = ` ssl_certificate /etc/nginx/certs/${site.domain}/fullchain.pem;\n`
165
+ + ` ssl_certificate_key /etc/nginx/certs/${site.domain}/privkey.pem;\n`
166
+ const proxy = ' proxy_set_header Host $host;\n'
167
+ + ' proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n'
168
+ + ' proxy_set_header X-Forwarded-Proto $scheme;\n'
169
+ const aliases = site.aliases.length === 0 ? '' : `
170
+ # The aliases: redirected to ${site.domain}
171
+ server {
172
+ listen 443 ssl;
173
+ http2 on;
174
+ server_name ${site.aliases.join(' ')};
175
+ ${cert} return 301 https://${site.domain}$request_uri;
176
+ }
177
+ `
178
+ const locations = site.withClient ? ` # The API (the server answers on /, as with the proxy of Vite in development)
179
+ location = /graphql {
180
+ rewrite ^ / break;
181
+ proxy_pass $api;
182
+ ${proxy} }
183
+
184
+ # The web site
185
+ location / {
186
+ proxy_pass $web;
187
+ ${proxy} }
188
+ ` : ` # The API
189
+ location / {
190
+ proxy_pass $api;
191
+ ${proxy} }
192
+ `
193
+ return `# ${HEADER}
194
+ # Site ${site.name}
195
+
196
+ server {
197
+ listen 80;
198
+ server_name ${[site.domain, ...site.aliases].join(' ')};
199
+
200
+ location /.well-known/acme-challenge/ {
201
+ root /var/www/certbot;
202
+ }
203
+
204
+ location / {
205
+ return 301 https://${site.domain}$request_uri;
206
+ }
207
+ }
208
+ ${aliases}
209
+ server {
210
+ listen 443 ssl;
211
+ http2 on;
212
+ server_name ${site.domain};
213
+ ${cert} add_header Strict-Transport-Security "max-age=31536000" always;
214
+ client_max_body_size 10m;
215
+
216
+ # Resolved at each request: nginx starts even when a container of the site is down
217
+ set $api http://${site.name}-api:${API_PORT};
218
+ ${site.withClient ? ` set $web http://${site.name}-web:80;\n` : ''}
219
+ ${locations}}
220
+ `
221
+ }
222
+
223
+ function apiDockerfile(site) {
224
+ const install = site.withClient
225
+ ? `COPY package.json package-lock.json ./
226
+ COPY server/package.json server/
227
+ COPY web/package.json web/
228
+ RUN npm ci --omit=dev --ignore-scripts -w server
229
+ COPY server/ server/
230
+ WORKDIR /app/server`
231
+ : `COPY package.json package-lock.json ./
232
+ RUN npm ci --omit=dev --ignore-scripts
233
+ COPY . .`
234
+ return `# syntax=docker/dockerfile:1
235
+ # ${HEADER}
236
+ # Site ${site.name}: the API (target api) and its backups (target backup), on the same image.
237
+
238
+ FROM node:22-alpine AS api
239
+ WORKDIR /app
240
+ # --ignore-scripts: better-sqlite3 ships its compiled binaries (musl, x64 and arm64), found when it loads; without
241
+ # it, npm would compile it again (node-gyp, which needs Python and a compiler)
242
+ ${install}
243
+ # The database volume, owned by the user that runs the server
244
+ RUN mkdir -p /data && chown node:node /data
245
+ USER node
246
+ ENV NODE_ENV=production
247
+ # node itself, not npm: SIGTERM reaches the server, which closes SQLite
248
+ CMD ["node", "src/index.js"]
249
+
250
+ FROM api AS backup
251
+ USER root
252
+ RUN apk add --no-cache openssh-client
253
+ USER node
254
+ CMD ["/app/node_modules/.bin/ramdb2-server-backup", "schedule"]
255
+ `
256
+ }
257
+
258
+ const WEB_DOCKERFILE = `# syntax=docker/dockerfile:1
259
+ # ${HEADER}
260
+ # The web site: compiled by Vite, then served by nginx.
261
+
262
+ FROM node:22-alpine AS build
263
+ WORKDIR /app
264
+ COPY package.json package-lock.json ./
265
+ COPY server/package.json server/
266
+ COPY web/package.json web/
267
+ RUN npm ci --ignore-scripts -w web
268
+ COPY web/ web/
269
+ RUN npm run build -w web
270
+
271
+ FROM nginx:alpine
272
+ RUN rm /etc/nginx/conf.d/default.conf
273
+ COPY --from=infra web.nginx.conf /etc/nginx/conf.d/web.conf
274
+ COPY --from=build /app/web/dist /usr/share/nginx/html
275
+ `
276
+
277
+ const WEB_NGINX = `# ${HEADER}
278
+ server {
279
+ listen 80;
280
+ root /usr/share/nginx/html;
281
+
282
+ # The pages of the Vue router: index.html, never cached, so that a new version is seen at once
283
+ location / {
284
+ try_files $uri $uri/ /index.html;
285
+ add_header Cache-Control "no-cache";
286
+ }
287
+
288
+ # The compiled files carry a hash in their name: cached for a year
289
+ location /assets/ {
290
+ try_files $uri =404;
291
+ add_header Cache-Control "public, max-age=31536000, immutable";
292
+ }
293
+ }
294
+ `
295
+
296
+ const DOCKERIGNORE = `# ${HEADER}
297
+ # Never in an image: the dependencies (installed by npm ci), the databases, the backups, the secrets.
298
+ **/node_modules
299
+ data
300
+ backups
301
+ server/data
302
+ server/backups
303
+ dist
304
+ web/dist
305
+ .env
306
+ .env.*
307
+ **/.env
308
+ **/.env.*
309
+ .git
310
+ **/test-results
311
+ **/playwright-report
312
+ `
313
+
314
+ const FRONT_DOCKERFILE = `# syntax=docker/dockerfile:1
315
+ # ${HEADER}
316
+ # The front nginx: HTTPS, one domain per site. The configuration is in the image (nothing mounted).
317
+
318
+ FROM nginx:alpine
319
+ RUN apk add --no-cache openssl && rm /etc/nginx/conf.d/default.conf
320
+ COPY --chmod=755 ramdb2-certs.sh /usr/local/bin/ramdb2-certs
321
+ COPY certificates /etc/nginx/ramdb2-certificates
322
+ COPY conf.d/ /etc/nginx/conf.d/
323
+ # The certificates linked, then a reload every 6 hours, for the certificates renewed by certbot
324
+ CMD ["/bin/sh", "-c", "ramdb2-certs || exit 1; (while :; do sleep 6h; ramdb2-certs && nginx -s reload; done) & exec nginx -g 'daemon off;'"]
325
+ `
326
+
327
+ const CERTS_SCRIPT = `#!/bin/sh
328
+ # ${HEADER}
329
+ # Points /etc/nginx/certs/<name> to the Let's Encrypt certificate <name>, or, until certbot has it, to a self-signed
330
+ # one: nginx can start before the first certificate.
331
+ set -e
332
+ mkdir -p /etc/nginx/certs /etc/nginx/self-signed
333
+ while read -r name; do
334
+ [ -n "$name" ] || continue
335
+ if [ -f "/etc/letsencrypt/live/$name/fullchain.pem" ]; then
336
+ ln -sfn "/etc/letsencrypt/live/$name" "/etc/nginx/certs/$name"
337
+ else
338
+ if [ ! -f "/etc/nginx/self-signed/$name/fullchain.pem" ]; then
339
+ mkdir -p "/etc/nginx/self-signed/$name"
340
+ openssl req -x509 -nodes -newkey rsa:2048 -days 30 -subj "/CN=$name" \\
341
+ -keyout "/etc/nginx/self-signed/$name/privkey.pem" -out "/etc/nginx/self-signed/$name/fullchain.pem" 2>/dev/null
342
+ fi
343
+ ln -sfn "/etc/nginx/self-signed/$name" "/etc/nginx/certs/$name"
344
+ fi
345
+ done < /etc/nginx/ramdb2-certificates
346
+ `
347
+
348
+ const FRONT_DEFAULTS = `# ${HEADER}
349
+ server_tokens off;
350
+ # The DNS of Docker: the containers are found by their name, at each request
351
+ resolver 127.0.0.11 valid=10s ipv6=off;
352
+ gzip on;
353
+ gzip_types text/css application/javascript application/json image/svg+xml;
354
+
355
+ # An unknown domain: no answer
356
+ server {
357
+ listen 80 default_server;
358
+
359
+ location /.well-known/acme-challenge/ {
360
+ root /var/www/certbot;
361
+ }
362
+
363
+ location / {
364
+ return 444;
365
+ }
366
+ }
367
+
368
+ server {
369
+ listen 443 ssl default_server;
370
+ ssl_reject_handshake on;
371
+ }
372
+ `
@@ -0,0 +1,165 @@
1
+ // infra.yaml (D55): the backups, the servers and their sites. Read, checked, with every path made absolute.
2
+ import { existsSync, readFileSync } from 'node:fs'
3
+ import { dirname, join, resolve } from 'node:path'
4
+ import { parse } from 'yaml'
5
+
6
+ const NAME = /^[a-z][a-z0-9-]*$/
7
+ const DOMAIN = /^(?=.{1,253}$)([a-z0-9]([a-z0-9-]{0,61}[a-z0-9])?\.)+[a-z]{2,63}$/
8
+ const MEMORY = /^\d+[kmg]$/
9
+
10
+ export class InfraError extends Error {
11
+ constructor(errors) {
12
+ super(`infra.yaml is not valid:\n${errors.map(error => ` - ${error}`).join('\n')}`)
13
+ this.name = 'InfraError'
14
+ this.errors = errors
15
+ }
16
+ }
17
+
18
+ /**
19
+ * @typedef {object} Site
20
+ * @property {string} name unique on all the servers
21
+ * @property {string} source the absolute path of the ramdb2 project
22
+ * @property {boolean} withClient a project of `new --with-client`: server/ and web/
23
+ * @property {string} domain
24
+ * @property {string[]} aliases
25
+ * @property {string | undefined} memory
26
+ *
27
+ * @typedef {object} Custom a site maintained by hand
28
+ * @property {string} name
29
+ * @property {string} nginx the absolute path of its nginx configuration
30
+ * @property {string | undefined} compose the absolute path of its compose file, if any
31
+ * @property {string[]} domains the domains whose certificates certbot keeps
32
+ *
33
+ * @typedef {object} Server
34
+ * @property {string} name
35
+ * @property {string} host
36
+ * @property {string} email
37
+ * @property {Site[]} sites
38
+ * @property {Custom[]} custom
39
+ *
40
+ * @typedef {object} Infra
41
+ * @property {string} dir the folder of infra.yaml
42
+ * @property {{target: string}} backup
43
+ * @property {Server[]} servers
44
+ */
45
+
46
+ /**
47
+ * Reads and checks infra.yaml. All the errors are reported at once.
48
+ * @param {string} file
49
+ * @returns {Infra}
50
+ */
51
+ export function readInfra(file) {
52
+ const dir = dirname(resolve(file))
53
+ let raw
54
+ try {
55
+ raw = parse(readFileSync(file, 'utf8'))
56
+ } catch (error) {
57
+ throw new InfraError([error.code === 'ENOENT' ? `${file} not found` : error.message])
58
+ }
59
+ const errors = []
60
+ const check = (condition, message) => {
61
+ if (!condition) errors.push(message)
62
+ return condition
63
+ }
64
+ if (!check(isObject(raw), 'expected an object with backup and servers')) throw new InfraError(errors)
65
+ unknownKeys(raw, ['backup', 'servers'], '', errors)
66
+
67
+ const backup = { target: raw.backup?.target }
68
+ if (check(isObject(raw.backup), 'backup: required, with target')) {
69
+ unknownKeys(raw.backup, ['target'], 'backup.', errors)
70
+ check(typeof backup.target === 'string' && /^sftp:\/\/[^@/]+@[^/]+(\/.*)?$/.test(backup.target),
71
+ 'backup.target: sftp://user@host[:port]/path')
72
+ }
73
+
74
+ const servers = []
75
+ const siteNames = new Map()
76
+ const domains = new Map()
77
+ const claim = (domain, owner) => {
78
+ if (domains.has(domain)) errors.push(`${owner}: ${domain} is already used by ${domains.get(domain)}`)
79
+ else domains.set(domain, owner)
80
+ }
81
+ if (check(isObject(raw.servers) && Object.keys(raw.servers).length > 0, 'servers: at least one server')) {
82
+ for (const [name, server] of Object.entries(raw.servers)) {
83
+ const at = `servers.${name}`
84
+ if (!check(NAME.test(name), `${at}: a name in lowercase letters, digits and dashes`)) continue
85
+ if (!check(isObject(server), `${at}: expected host, email and sites`)) continue
86
+ unknownKeys(server, ['host', 'email', 'sites', 'custom'], `${at}.`, errors)
87
+ check(typeof server.host === 'string' && /^ssh:\/\/[^/]+$/.test(server.host), `${at}.host: ssh://user@host[:port]`)
88
+ check(typeof server.email === 'string' && /^[^@\s]+@[^@\s]+$/.test(server.email), `${at}.email: the Let's Encrypt account`)
89
+ const sites = []
90
+ for (const [siteName, site] of Object.entries(server.sites ?? {})) {
91
+ const siteAt = `${at}.sites.${siteName}`
92
+ if (!check(NAME.test(siteName), `${siteAt}: a name in lowercase letters, digits and dashes`)) continue
93
+ if (siteNames.has(siteName)) {
94
+ errors.push(`${siteAt}: the name is already used on ${siteNames.get(siteName)} (a site name is unique on all the servers)`)
95
+ continue
96
+ }
97
+ siteNames.set(siteName, `servers.${name}`)
98
+ if (!check(isObject(site), `${siteAt}: expected source and domain`)) continue
99
+ unknownKeys(site, ['source', 'domain', 'aliases', 'memory'], `${siteAt}.`, errors)
100
+ const source = typeof site.source === 'string' ? resolve(dir, site.source) : undefined
101
+ let withClient = false
102
+ if (check(source !== undefined, `${siteAt}.source: the folder of the ramdb2 project`)) {
103
+ const pkg = readPackage(join(source, 'package.json'))
104
+ if (check(pkg !== null, `${siteAt}.source: no package.json in ${source}`)) {
105
+ withClient = Array.isArray(pkg.workspaces) && pkg.workspaces.includes('server') && pkg.workspaces.includes('web')
106
+ const lock = existsSync(join(source, 'package-lock.json'))
107
+ check(lock, `${siteAt}.source: no package-lock.json in ${source} (run npm install there)`)
108
+ }
109
+ }
110
+ const aliases = site.aliases ?? []
111
+ if (check(typeof site.domain === 'string' && DOMAIN.test(site.domain), `${siteAt}.domain: a domain name in lowercase`)) {
112
+ claim(site.domain, siteAt)
113
+ }
114
+ if (check(Array.isArray(aliases) && aliases.every(alias => typeof alias === 'string' && DOMAIN.test(alias)),
115
+ `${siteAt}.aliases: a list of domain names in lowercase`)) {
116
+ for (const alias of aliases) claim(alias, siteAt)
117
+ }
118
+ check(site.memory === undefined || (typeof site.memory === 'string' && MEMORY.test(site.memory)),
119
+ `${siteAt}.memory: a size, e.g. 512m or 2g`)
120
+ sites.push({ name: siteName, source, withClient, domain: site.domain, aliases, memory: site.memory })
121
+ }
122
+ const custom = []
123
+ if (check(server.custom === undefined || Array.isArray(server.custom), `${at}.custom: a list`)) {
124
+ for (const [index, entry] of (server.custom ?? []).entries()) {
125
+ const customAt = `${at}.custom[${index}]`
126
+ const item = typeof entry === 'string' ? { name: entry } : entry
127
+ if (!check(isObject(item) && typeof item.name === 'string' && NAME.test(item.name),
128
+ `${customAt}: a name, or { name, domains }`)) continue
129
+ unknownKeys(item, ['name', 'domains'], `${customAt}.`, errors)
130
+ const nginx = join(dir, 'custom', `${item.name}.nginx.conf`)
131
+ const compose = join(dir, 'custom', `${item.name}.compose.yaml`)
132
+ check(existsSync(nginx), `${customAt}: custom/${item.name}.nginx.conf not found`)
133
+ const customDomains = item.domains ?? []
134
+ if (check(Array.isArray(customDomains) && customDomains.every(domain => typeof domain === 'string' && DOMAIN.test(domain)),
135
+ `${customAt}.domains: a list of domain names in lowercase`)) {
136
+ for (const domain of customDomains) claim(domain, customAt)
137
+ }
138
+ custom.push({ name: item.name, nginx, compose: existsSync(compose) ? compose : undefined, domains: customDomains })
139
+ }
140
+ }
141
+ check(sites.length + custom.length > 0, `${at}: no site`)
142
+ servers.push({ name, host: server.host, email: server.email, sites, custom })
143
+ }
144
+ }
145
+ if (errors.length > 0) throw new InfraError(errors)
146
+ return { dir, backup, servers }
147
+ }
148
+
149
+ function isObject(value) {
150
+ return value !== null && typeof value === 'object' && !Array.isArray(value)
151
+ }
152
+
153
+ function unknownKeys(object, known, at, errors) {
154
+ for (const key of Object.keys(object)) {
155
+ if (!known.includes(key)) errors.push(`${at}${key}: unknown key (expected ${known.join(', ')})`)
156
+ }
157
+ }
158
+
159
+ function readPackage(file) {
160
+ try {
161
+ return JSON.parse(readFileSync(file, 'utf8'))
162
+ } catch {
163
+ return null
164
+ }
165
+ }