@powerhousedao/registry 6.2.3-dev.6 → 6.2.3-dev.60
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/README.md +151 -26
- package/dist/cli.d.mts +122 -19
- package/dist/cli.d.mts.map +1 -1
- package/dist/cli.mjs +5304 -819
- package/dist/cli.mjs.map +1 -1
- package/dist/plugins/@powerhousedao/verdaccio-s3-storage/es5-CoIkS7gl.js +1723 -0
- package/dist/plugins/@powerhousedao/verdaccio-s3-storage/index.js +53926 -0
- package/dist/plugins/@powerhousedao/verdaccio-s3-storage/rolldown-runtime-ch10HqoO.js +71 -0
- package/dist/plugins/verdaccio-registry-auth.js +423 -30
- package/package.json +12 -12
package/README.md
CHANGED
|
@@ -1,6 +1,16 @@
|
|
|
1
1
|
# @powerhousedao/registry
|
|
2
2
|
|
|
3
|
-
Powerhouse package registry built on Verdaccio. Serves as both an npm registry and a CDN for Powerhouse package bundles (ESM) for dynamic `import()` in browsers and Node.js.
|
|
3
|
+
Powerhouse package registry built on Verdaccio 7. Serves as both an npm registry and a CDN for Powerhouse package bundles (ESM) for dynamic `import()` in browsers and Node.js.
|
|
4
|
+
|
|
5
|
+
## How it works
|
|
6
|
+
|
|
7
|
+
- **npm protocol:** Verdaccio. With S3 configured it stores package files in the bucket and its package list, tokens and secret in Postgres, through the bundled `@powerhousedao/verdaccio-s3-storage` plugin.
|
|
8
|
+
- **Publishing:** a successful publish records the version as pending, and a job to process it, in one transaction before the response goes out.
|
|
9
|
+
- **Processing:** a worker takes the job, unpacks the tarball once, and writes the files and piece bundles to the artifact store (S3 under `artifacts/`, or the local data directory) and the package, version and piece rows to Postgres. Jobs retry with backoff; a version that keeps failing is marked failed with the reason.
|
|
10
|
+
- **Reconciling:** every minute the worker compares each package's manifest revision in the storage plugin's index with the one its last sync applied, and syncs the ones that differ; hourly it compares every version. The first pass after upgrading syncs every package once.
|
|
11
|
+
- **Reading:** `/packages`, `/pieces`, `/-/cdn` and piece bundles read Postgres and the artifact store, so every replica answers the same. A version nobody processed yet, such as an npmjs package requested through the CDN, is processed on demand.
|
|
12
|
+
|
|
13
|
+
Every replica is stateless and interchangeable. Without `--database-url` the registry keeps its state in an embedded PGlite and runs its jobs in-process, which suits local development.
|
|
4
14
|
|
|
5
15
|
## API
|
|
6
16
|
|
|
@@ -8,12 +18,24 @@ Powerhouse package registry built on Verdaccio. Serves as both an npm registry a
|
|
|
8
18
|
|
|
9
19
|
#### `GET /packages`
|
|
10
20
|
|
|
11
|
-
Returns a
|
|
21
|
+
Returns a page of packages at their latest version, with an `ETag` for revalidation:
|
|
12
22
|
|
|
13
|
-
```
|
|
14
|
-
|
|
23
|
+
```json
|
|
24
|
+
{ "items": [], "total": 0, "limit": 30, "offset": 0, "hasMore": false }
|
|
15
25
|
```
|
|
16
26
|
|
|
27
|
+
| Parameter | Meaning |
|
|
28
|
+
| ------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- |
|
|
29
|
+
| `limit`, `offset` | Page size (1–50, default 30) and start |
|
|
30
|
+
| `search` | Full-text (stemmed), fuzzy (typo-tolerant) or substring match over the npm and manifest names, description, publisher, and module names and ids. Name substrings rank first, then other substrings, then by score |
|
|
31
|
+
| `name` | Only these packages, by npm or manifest name (repeatable) |
|
|
32
|
+
| `category`, `publisher`, `moduleType` | Manifest filters, repeatable; values of one filter OR, filters AND. `moduleType` is `documentModels`, `editors`, `apps`, `subgraphs` or `processors` |
|
|
33
|
+
| `documentType` | Only packages whose manifest defines this document model |
|
|
34
|
+
| `detail=full` | Items are full package info (manifest, document types, versions, owners) instead of list cards |
|
|
35
|
+
| `facets=true` | Adds `facets: { categories, publishers }` over the `name`-restricted set |
|
|
36
|
+
|
|
37
|
+
Search runs in Postgres on `pg_trgm` and full-text indexes (migration 3); the database user must be able to `CREATE EXTENSION pg_trgm`, which the database owner can.
|
|
38
|
+
|
|
17
39
|
#### `GET /packages/by-document-type?type=<documentType>`
|
|
18
40
|
|
|
19
41
|
Returns an array of package names that contain the specified document type.
|
|
@@ -32,6 +54,61 @@ If the package is not published locally, Verdaccio transparently proxies metadat
|
|
|
32
54
|
|
|
33
55
|
Responses carry caching headers keyed on the request shape. Version-pinned requests (`<pkg>@1.2.3/...`) are served `Cache-Control: public, max-age=31536000, immutable`; moving requests (a dist-tag like `@dev`/`@latest`, or untagged) get `public, max-age=60, must-revalidate`. A version-derived weak `ETag` is sent, and a matching `If-None-Match` returns `304`. When the upstream metadata lookup fails (as opposed to a genuine not-found), the endpoint serves the latest cached version if present, otherwise responds `503` rather than a cacheable `404`.
|
|
34
56
|
|
|
57
|
+
### Pieces
|
|
58
|
+
|
|
59
|
+
A reactor's workflow runtime reads pieces from these endpoints, ahead of the
|
|
60
|
+
Activepieces catalogue.
|
|
61
|
+
|
|
62
|
+
#### `GET /pieces`
|
|
63
|
+
|
|
64
|
+
The catalog of pieces that published packages ship, in the shape of
|
|
65
|
+
cloud.activepieces.com's list endpoint, as a page shaped like `/packages`'.
|
|
66
|
+
`limit` and `offset` page it, `search` matches the name, display name and
|
|
67
|
+
description like `/packages` does, and `?suggestionType=ACTION_AND_TRIGGER`
|
|
68
|
+
adds suggested actions and triggers.
|
|
69
|
+
|
|
70
|
+
#### `GET /pieces/<name>` and `GET /pieces/<name>?version=<v>`
|
|
71
|
+
|
|
72
|
+
One piece's detail: the latest version, or the one named. An unknown version
|
|
73
|
+
returns `404` with `available`, the versions the registry has.
|
|
74
|
+
|
|
75
|
+
#### `GET /pieces/<name>/versions`
|
|
76
|
+
|
|
77
|
+
Every version of the piece: `[{ version, packageVersion, publishedAt }]`. A
|
|
78
|
+
piece's version is always the version of the package that ships it.
|
|
79
|
+
|
|
80
|
+
#### `GET /-/pieces/bundled/<name>/<version>.tgz`
|
|
81
|
+
|
|
82
|
+
The piece directory as an npm-shaped tarball, the file a reactor's piece worker
|
|
83
|
+
downloads, e.g. `/-/pieces/bundled/@acme/slack/1.2.0.tgz`. It is served
|
|
84
|
+
immutable.
|
|
85
|
+
|
|
86
|
+
A piece name belongs to the first package that ships it, like an npm package
|
|
87
|
+
name: workflows refer to a piece by name and version on any switchboard.
|
|
88
|
+
Names under `@activepieces/` are reserved: a package that claims one is
|
|
89
|
+
refused.
|
|
90
|
+
|
|
91
|
+
### Health
|
|
92
|
+
|
|
93
|
+
- `GET /-/live`: 200 while the process serves HTTP; for liveness probes.
|
|
94
|
+
- `GET /-/ready`: 200 when Postgres answers and notifications are flowing, 503 otherwise and while draining after `SIGTERM`; for readiness probes.
|
|
95
|
+
|
|
96
|
+
### Metrics
|
|
97
|
+
|
|
98
|
+
`GET /-/metrics` returns Prometheus text. `ph-registry worker` serves the same path on `--metrics-port` (`PH_REGISTRY_METRICS_PORT`), and serves nothing without it.
|
|
99
|
+
|
|
100
|
+
| Metric | Where | Meaning |
|
|
101
|
+
| ------------------------------------------------------------------------------------------------- | -------------- | ---------------------------------------------------------------------- |
|
|
102
|
+
| `registry_jobs`, `registry_jobs_due`, `registry_jobs_running`, `registry_jobs_oldest_due_seconds` | both | The job queue by `priority`, queried on scrape and cached for 5 s |
|
|
103
|
+
| `registry_job_duration_seconds` | where jobs run | Histogram by `kind` and `outcome` (`done`, `retry`, `failed`) |
|
|
104
|
+
| `registry_reconcile_runs_total`, `registry_reconcile_queued_total` | where jobs run | Reconcile passes and the jobs they queued, by `pass` (`quick`, `full`) |
|
|
105
|
+
| `registry_listen_connected` | both | 1 while the LISTEN connection is up |
|
|
106
|
+
| `registry_http_requests_total`, `registry_http_request_duration_seconds` | replicas | By `route` group; the count also by `method` and `status` class |
|
|
107
|
+
| `nodejs_eventloop_delay_seconds` | both | Event-loop delay quantiles since the previous scrape |
|
|
108
|
+
| `process_resident_memory_bytes`, `nodejs_heap_bytes`, `process_cpu_seconds_total` | both | Memory and CPU |
|
|
109
|
+
|
|
110
|
+
The endpoint needs no credentials; keep it off the public ingress if the queue figures matter.
|
|
111
|
+
|
|
35
112
|
### Publish Notifications
|
|
36
113
|
|
|
37
114
|
When a package is published, the registry can notify subscribers in real time via Server-Sent Events (SSE) and webhooks.
|
|
@@ -108,7 +185,9 @@ All standard npm registry operations (publish, install, etc.) are handled by Ver
|
|
|
108
185
|
npm publish --registry http://localhost:8080/
|
|
109
186
|
```
|
|
110
187
|
|
|
111
|
-
|
|
188
|
+
A publish is recorded before the registry replies, and a worker processes it, usually within a second; the CDN, `/packages` and `/pieces` serve it from then on.
|
|
189
|
+
|
|
190
|
+
A version that was unpublished can't be published again: the registry answers `409`, as npm does. Pinned CDN files, piece bundles and tarballs are cached as immutable, so a reused version number would keep serving the old bytes. Publish a new version instead. To lift the rule for one version, delete its row from `registry_unpublished`.
|
|
112
191
|
|
|
113
192
|
## CLI
|
|
114
193
|
|
|
@@ -116,26 +195,43 @@ On publish, the CDN cache for that package is automatically invalidated and the
|
|
|
116
195
|
ph-registry --port 8080 --storage-dir ./storage --cdn-cache-dir ./cdn-cache
|
|
117
196
|
```
|
|
118
197
|
|
|
198
|
+
Other roles share the storage options below:
|
|
199
|
+
|
|
200
|
+
| Command | Does |
|
|
201
|
+
| ------------------------------------ | --------------------------------------------------------------------------------------------------------------------------------------- |
|
|
202
|
+
| `ph-registry` | Runs the registry. With `--workers 0` it only records jobs, for a deployment with separate workers. |
|
|
203
|
+
| `ph-registry worker` | Runs jobs against a replica's npm endpoint (`--registry-url`, `PH_REGISTRY_INTERNAL_URL`); `--metrics-port` serves [metrics](#metrics). |
|
|
204
|
+
| `ph-registry migrate [--backfill]` | Applies the database migrations; `--backfill` also queues processing of every package published here. See [Migrations](#migrations). |
|
|
205
|
+
| `ph-registry import-verdaccio-state` | Copies Verdaccio's package list, tokens and secret from the old `verdaccio-s3-db.json`, plus every package stored in S3, into Postgres. |
|
|
206
|
+
|
|
119
207
|
Options:
|
|
120
208
|
|
|
121
|
-
| Option
|
|
122
|
-
|
|
|
123
|
-
| `--port`
|
|
124
|
-
| `--storage-dir`
|
|
125
|
-
| `--cdn-cache-dir`
|
|
126
|
-
| `--
|
|
127
|
-
| `--
|
|
128
|
-
| `--
|
|
129
|
-
| `--
|
|
130
|
-
| `--
|
|
131
|
-
| `--
|
|
132
|
-
| `--
|
|
133
|
-
| `--
|
|
134
|
-
| `--
|
|
135
|
-
| `--
|
|
136
|
-
| `--
|
|
137
|
-
| `--
|
|
138
|
-
| `--
|
|
209
|
+
| Option | Env Variable | Default | Description |
|
|
210
|
+
| ------------------------- | ----------------------------------- | ----------------------------- | ---------------------------------------------------------------------------------------------------------------------------- |
|
|
211
|
+
| `--port` | `PORT` | `8080` | Port to listen on |
|
|
212
|
+
| `--storage-dir` | `REGISTRY_STORAGE` | `./storage` | Verdaccio storage directory |
|
|
213
|
+
| `--cdn-cache-dir` | `REGISTRY_CDN_CACHE` | `./cdn-cache` | Local data directory: processed packages and the embedded database, when no S3 bucket or Postgres URL is set |
|
|
214
|
+
| `--database-url` | `PH_REGISTRY_DATABASE_URL` | — | Postgres shared by every replica and worker; required with S3 |
|
|
215
|
+
| `--listen-database-url` | `PH_REGISTRY_LISTEN_DATABASE_URL` | `--database-url` | A direct connection for LISTEN/NOTIFY when `--database-url` goes through a transaction pooler |
|
|
216
|
+
| `--workers` | `PH_REGISTRY_WORKERS` | `1` | Jobs the registry process runs at a time; `0` leaves them to `ph-registry worker` |
|
|
217
|
+
| `--artifact-cache-mb` | `PH_REGISTRY_ARTIFACT_CACHE_MB` | `128` | Memory for serving published files up to 1 MiB without reading S3; unpublishing a version evicts its files. `0` turns it off |
|
|
218
|
+
| `--db-pool-max` | `PH_REGISTRY_DB_POOL_MAX` | `10` | Connections in the process's own Postgres pool (registry and worker) |
|
|
219
|
+
| `--storage-pool-max` | `PH_REGISTRY_STORAGE_POOL_MAX` | `2` | Connections for the storage plugin's reads: package list, tokens, secret |
|
|
220
|
+
| `--storage-lock-pool-max` | `PH_REGISTRY_STORAGE_LOCK_POOL_MAX` | `4` | Connections holding the storage plugin's package locks, one per concurrent manifest write |
|
|
221
|
+
| `--migrate-on-boot` | `PH_REGISTRY_MIGRATE_ON_BOOT` | `true` without a database URL | `true` or `false`: apply migrations at startup instead of only checking the schema is current |
|
|
222
|
+
| `--uplink` | `REGISTRY_UPLINK` | `https://registry.npmjs.org/` | Upstream npm registry URL used for fallback proxy |
|
|
223
|
+
| `--web-enabled` | `REGISTRY_WEB` | `true` | Enable Verdaccio web UI |
|
|
224
|
+
| `--webhook` | `REGISTRY_WEBHOOKS` | — | Comma-separated webhook URLs to notify on publish |
|
|
225
|
+
| `--s3-bucket` | `S3_BUCKET` | — | S3 bucket for storage |
|
|
226
|
+
| `--s3-endpoint` | `S3_ENDPOINT` | — | S3 endpoint URL |
|
|
227
|
+
| `--s3-region` | `S3_REGION` | — | S3 region |
|
|
228
|
+
| `--s3-access-key-id` | `S3_ACCESS_KEY_ID` | — | S3 access key |
|
|
229
|
+
| `--s3-secret-access-key` | `S3_SECRET_ACCESS_KEY` | — | S3 secret key |
|
|
230
|
+
| `--s3-key-prefix` | `S3_KEY_PREFIX` | — | S3 key prefix |
|
|
231
|
+
| `--s3-force-path-style` | `S3_FORCE_PATH_STYLE` | `true` | Force S3 path-style URLs |
|
|
232
|
+
| `--public-url` | `PH_REGISTRY_PUBLIC_URL` | — | Public URL of this registry — required when Renown auth is enabled. Used as the expected `aud` claim on bearer tokens. |
|
|
233
|
+
| `--auth-renown` | `PH_REGISTRY_AUTH_RENOWN` | `true` | Enable Renown JWT auth in front of verdaccio. Disabled (no-op) when `--public-url` is unset. |
|
|
234
|
+
| `--verdaccio-secret` | `PH_REGISTRY_VERDACCIO_SECRET` | — | Seeds Verdaccio's stored signing secret (32 characters) when none is stored yet, so tokens it already signed stay valid |
|
|
139
235
|
|
|
140
236
|
## Authentication
|
|
141
237
|
|
|
@@ -148,12 +244,41 @@ Two authentication paths are supported:
|
|
|
148
244
|
invocation) or `ph registry-login` (writes a longer-lived token to
|
|
149
245
|
`~/.npmrc` for raw `npm publish`).
|
|
150
246
|
|
|
151
|
-
2. **
|
|
152
|
-
|
|
153
|
-
|
|
247
|
+
2. **Accounts.** With a database, `npm adduser` and `npm login` go through the
|
|
248
|
+
registry's auth plugin, which keeps accounts and package ownership in
|
|
249
|
+
Postgres. Verdaccio 7 accepts no HTTP Basic auth, so the plugin treats an
|
|
250
|
+
`adduser` with an existing user's correct password as a login. Without a
|
|
251
|
+
database, Verdaccio's htpasswd file is used.
|
|
252
|
+
|
|
253
|
+
## Migrations
|
|
254
|
+
|
|
255
|
+
`ph-registry migrate` applies the database migrations; production runs it once per release, before the new pods start. With `--database-url` set, the registry and the worker only check the schema at startup, and refuse to start while a migration is missing. Without one, the embedded PGlite is migrated at startup, so tests and local `ph` use need no separate step. `--migrate-on-boot true` migrates at startup with Postgres as well; any number of processes may migrate at once.
|
|
256
|
+
|
|
257
|
+
Most migrations run in one transaction with `lock_timeout = 5s`. A migration marked `transaction: false` runs each statement on its own, for `CREATE INDEX CONCURRENTLY`: it holds a session advisory lock, so it connects through `--listen-database-url` when that is set, and an index left INVALID by a failed build is dropped and rebuilt on the next run. Migrations must keep the previous release working, since it still serves while the new one rolls out.
|
|
258
|
+
|
|
259
|
+
## Moving an existing S3 deployment
|
|
260
|
+
|
|
261
|
+
1. `ph-registry migrate` creates the registry's tables.
|
|
262
|
+
2. `ph-registry import-verdaccio-state` moves Verdaccio's state into Postgres, including names the old shared list lost.
|
|
263
|
+
3. Deploy the new version, with `ph-registry worker` if the replicas run `--workers 0`.
|
|
264
|
+
4. `ph-registry migrate --backfill` queues processing of every existing version; the worker's hourly sweep also does this, behind any publish.
|
|
154
265
|
|
|
155
266
|
## Deployment
|
|
156
267
|
|
|
268
|
+
### Database connections
|
|
269
|
+
|
|
270
|
+
Each process opens at most these connections, with the defaults:
|
|
271
|
+
|
|
272
|
+
| Process | Through `--database-url` (the pooler) | Direct (`--listen-database-url`) |
|
|
273
|
+
| ---------------- | --------------------------------------------------------------------------------------- | ------------------------------------------------ |
|
|
274
|
+
| Registry replica | 16: its own pool (10), the storage plugin's pool (2) and lock pool (4) | 1 for LISTEN; 1 more while migrating, if it does |
|
|
275
|
+
| `worker` | 10: its own pool; each running job uses one at a time, so keep it above `--concurrency` | 1 for LISTEN |
|
|
276
|
+
| `migrate` | 10, briefly | 1 while an online migration runs |
|
|
277
|
+
|
|
278
|
+
Behind pgbouncer in transaction mode these are client connections, bounded by `MAX_CLIENT_CONN`: six replicas and a worker make at most 6 × 16 + 10 = 106. A client holds a server connection only during a transaction, and `DEFAULT_POOL_SIZE` caps the server connections for the registry's user and database across every process; past it, transactions queue in pgbouncer.
|
|
279
|
+
|
|
280
|
+
Most transactions take milliseconds, but a package-lock transaction lasts as long as the manifest's S3 write. With alpha's `DEFAULT_POOL_SIZE` of 20, six replicas with full lock pools (6 × 4 = 24) would hold every server connection, and the worker's jobs and every read would wait behind S3. Raise `DEFAULT_POOL_SIZE` before `--storage-lock-pool-max`, and keep Postgres' `max_connections` above `DEFAULT_POOL_SIZE` plus the direct connections, one per replica and worker.
|
|
281
|
+
|
|
157
282
|
### Build
|
|
158
283
|
|
|
159
284
|
```sh
|
package/dist/cli.d.mts
CHANGED
|
@@ -1,15 +1,8 @@
|
|
|
1
|
-
import * as cmd_ts_dist_cjs_argparser_js0 from "cmd-ts/dist/cjs/argparser.js";
|
|
2
|
-
import * as cmd_ts_dist_cjs_helpdoc_js0 from "cmd-ts/dist/cjs/helpdoc.js";
|
|
3
|
-
import * as cmd_ts_dist_cjs_runner_js0 from "cmd-ts/dist/cjs/runner.js";
|
|
4
|
-
|
|
5
1
|
//#region cli.d.ts
|
|
6
|
-
declare const registryCommand: Partial<
|
|
7
|
-
parse(context:
|
|
8
|
-
port: number;
|
|
2
|
+
export declare const registryCommand: Partial<import("cmd-ts/dist/cjs/argparser.js").Register> & {
|
|
3
|
+
parse(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
|
|
9
4
|
storageDir: string;
|
|
10
5
|
cdnCacheDir: string;
|
|
11
|
-
uplink: string | undefined;
|
|
12
|
-
uplinkMaxage: string | undefined;
|
|
13
6
|
s3Bucket: string | undefined;
|
|
14
7
|
s3Endpoint: string | undefined;
|
|
15
8
|
s3Region: string | undefined;
|
|
@@ -17,21 +10,30 @@ declare const registryCommand: Partial<cmd_ts_dist_cjs_argparser_js0.Register> &
|
|
|
17
10
|
s3SecretAccessKey: string | undefined;
|
|
18
11
|
s3KeyPrefix: string | undefined;
|
|
19
12
|
s3ForcePathStyle: boolean;
|
|
20
|
-
|
|
13
|
+
s3MaxWritesPerSecond: number | undefined;
|
|
14
|
+
databaseUrl: string | undefined;
|
|
15
|
+
listenDatabaseUrl: string | undefined;
|
|
21
16
|
webhooks: string | undefined;
|
|
17
|
+
migrateOnBoot: boolean | undefined;
|
|
18
|
+
dbPoolMax: number | undefined;
|
|
19
|
+
storagePoolMax: number | undefined;
|
|
20
|
+
storageLockPoolMax: number | undefined;
|
|
21
|
+
port: number;
|
|
22
|
+
artifactCacheMb: number;
|
|
23
|
+
workers: number;
|
|
24
|
+
uplink: string | undefined;
|
|
25
|
+
uplinkMaxage: string | undefined;
|
|
26
|
+
trustProxy: string | undefined;
|
|
27
|
+
webEnabled: boolean;
|
|
22
28
|
publicUrl: string | undefined;
|
|
23
29
|
authRenown: boolean;
|
|
24
30
|
renownUrl: string | undefined;
|
|
25
31
|
verdaccioSecret: string | undefined;
|
|
26
32
|
localPackages: string | undefined;
|
|
27
|
-
databaseUrl: string | undefined;
|
|
28
33
|
}>>;
|
|
29
|
-
} &
|
|
30
|
-
port: number;
|
|
34
|
+
} & import("cmd-ts/dist/cjs/helpdoc.js").PrintHelp & import("cmd-ts/dist/cjs/helpdoc.js").ProvidesHelp & import("cmd-ts/dist/cjs/helpdoc.js").Named & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned> & import("cmd-ts/dist/cjs/argparser.js").Register & import("cmd-ts/dist/cjs/runner.js").Handling<{
|
|
31
35
|
storageDir: string;
|
|
32
36
|
cdnCacheDir: string;
|
|
33
|
-
uplink: string | undefined;
|
|
34
|
-
uplinkMaxage: string | undefined;
|
|
35
37
|
s3Bucket: string | undefined;
|
|
36
38
|
s3Endpoint: string | undefined;
|
|
37
39
|
s3Region: string | undefined;
|
|
@@ -39,17 +41,118 @@ declare const registryCommand: Partial<cmd_ts_dist_cjs_argparser_js0.Register> &
|
|
|
39
41
|
s3SecretAccessKey: string | undefined;
|
|
40
42
|
s3KeyPrefix: string | undefined;
|
|
41
43
|
s3ForcePathStyle: boolean;
|
|
42
|
-
|
|
44
|
+
s3MaxWritesPerSecond: number | undefined;
|
|
45
|
+
databaseUrl: string | undefined;
|
|
46
|
+
listenDatabaseUrl: string | undefined;
|
|
43
47
|
webhooks: string | undefined;
|
|
48
|
+
migrateOnBoot: boolean | undefined;
|
|
49
|
+
dbPoolMax: number | undefined;
|
|
50
|
+
storagePoolMax: number | undefined;
|
|
51
|
+
storageLockPoolMax: number | undefined;
|
|
52
|
+
port: number;
|
|
53
|
+
artifactCacheMb: number;
|
|
54
|
+
workers: number;
|
|
55
|
+
uplink: string | undefined;
|
|
56
|
+
uplinkMaxage: string | undefined;
|
|
57
|
+
trustProxy: string | undefined;
|
|
58
|
+
webEnabled: boolean;
|
|
44
59
|
publicUrl: string | undefined;
|
|
45
60
|
authRenown: boolean;
|
|
46
61
|
renownUrl: string | undefined;
|
|
47
62
|
verdaccioSecret: string | undefined;
|
|
48
63
|
localPackages: string | undefined;
|
|
64
|
+
}, Promise<void>> & {
|
|
65
|
+
run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<Promise<void>>>;
|
|
66
|
+
} & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned & import("cmd-ts/dist/cjs/helpdoc.js").Descriptive & import("cmd-ts/dist/cjs/helpdoc.js").Aliased>;
|
|
67
|
+
export declare const workerCommand: Partial<import("cmd-ts/dist/cjs/argparser.js").Register> & {
|
|
68
|
+
parse(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
|
|
69
|
+
storageDir: string;
|
|
70
|
+
cdnCacheDir: string;
|
|
71
|
+
s3Bucket: string | undefined;
|
|
72
|
+
s3Endpoint: string | undefined;
|
|
73
|
+
s3Region: string | undefined;
|
|
74
|
+
s3AccessKeyId: string | undefined;
|
|
75
|
+
s3SecretAccessKey: string | undefined;
|
|
76
|
+
s3KeyPrefix: string | undefined;
|
|
77
|
+
s3ForcePathStyle: boolean;
|
|
78
|
+
s3MaxWritesPerSecond: number | undefined;
|
|
79
|
+
databaseUrl: string | undefined;
|
|
80
|
+
listenDatabaseUrl: string | undefined;
|
|
81
|
+
webhooks: string | undefined;
|
|
82
|
+
migrateOnBoot: boolean | undefined;
|
|
83
|
+
dbPoolMax: number | undefined;
|
|
84
|
+
registryUrl: string;
|
|
85
|
+
concurrency: number;
|
|
86
|
+
metricsPort: number | undefined;
|
|
87
|
+
}>>;
|
|
88
|
+
} & import("cmd-ts/dist/cjs/helpdoc.js").PrintHelp & import("cmd-ts/dist/cjs/helpdoc.js").ProvidesHelp & import("cmd-ts/dist/cjs/helpdoc.js").Named & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned> & import("cmd-ts/dist/cjs/argparser.js").Register & import("cmd-ts/dist/cjs/runner.js").Handling<{
|
|
89
|
+
storageDir: string;
|
|
90
|
+
cdnCacheDir: string;
|
|
91
|
+
s3Bucket: string | undefined;
|
|
92
|
+
s3Endpoint: string | undefined;
|
|
93
|
+
s3Region: string | undefined;
|
|
94
|
+
s3AccessKeyId: string | undefined;
|
|
95
|
+
s3SecretAccessKey: string | undefined;
|
|
96
|
+
s3KeyPrefix: string | undefined;
|
|
97
|
+
s3ForcePathStyle: boolean;
|
|
98
|
+
s3MaxWritesPerSecond: number | undefined;
|
|
99
|
+
databaseUrl: string | undefined;
|
|
100
|
+
listenDatabaseUrl: string | undefined;
|
|
101
|
+
webhooks: string | undefined;
|
|
102
|
+
migrateOnBoot: boolean | undefined;
|
|
103
|
+
dbPoolMax: number | undefined;
|
|
104
|
+
registryUrl: string;
|
|
105
|
+
concurrency: number;
|
|
106
|
+
metricsPort: number | undefined;
|
|
107
|
+
}, Promise<void>> & {
|
|
108
|
+
run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<Promise<void>>>;
|
|
109
|
+
} & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned & import("cmd-ts/dist/cjs/helpdoc.js").Descriptive & import("cmd-ts/dist/cjs/helpdoc.js").Aliased>;
|
|
110
|
+
export declare const migrateCommand: Partial<import("cmd-ts/dist/cjs/argparser.js").Register> & {
|
|
111
|
+
parse(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
|
|
112
|
+
databaseUrl: string | undefined;
|
|
113
|
+
listenDatabaseUrl: string | undefined;
|
|
114
|
+
backfill: boolean;
|
|
115
|
+
}>>;
|
|
116
|
+
} & import("cmd-ts/dist/cjs/helpdoc.js").PrintHelp & import("cmd-ts/dist/cjs/helpdoc.js").ProvidesHelp & import("cmd-ts/dist/cjs/helpdoc.js").Named & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned> & import("cmd-ts/dist/cjs/argparser.js").Register & import("cmd-ts/dist/cjs/runner.js").Handling<{
|
|
49
117
|
databaseUrl: string | undefined;
|
|
118
|
+
listenDatabaseUrl: string | undefined;
|
|
119
|
+
backfill: boolean;
|
|
120
|
+
}, Promise<void>> & {
|
|
121
|
+
run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<Promise<void>>>;
|
|
122
|
+
} & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned & import("cmd-ts/dist/cjs/helpdoc.js").Descriptive & import("cmd-ts/dist/cjs/helpdoc.js").Aliased>;
|
|
123
|
+
export declare const importVerdaccioStateCommand: Partial<import("cmd-ts/dist/cjs/argparser.js").Register> & {
|
|
124
|
+
parse(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<{
|
|
125
|
+
storageDir: string;
|
|
126
|
+
cdnCacheDir: string;
|
|
127
|
+
s3Bucket: string | undefined;
|
|
128
|
+
s3Endpoint: string | undefined;
|
|
129
|
+
s3Region: string | undefined;
|
|
130
|
+
s3AccessKeyId: string | undefined;
|
|
131
|
+
s3SecretAccessKey: string | undefined;
|
|
132
|
+
s3KeyPrefix: string | undefined;
|
|
133
|
+
s3ForcePathStyle: boolean;
|
|
134
|
+
s3MaxWritesPerSecond: number | undefined;
|
|
135
|
+
databaseUrl: string | undefined;
|
|
136
|
+
listenDatabaseUrl: string | undefined;
|
|
137
|
+
webhooks: string | undefined;
|
|
138
|
+
}>>;
|
|
139
|
+
} & import("cmd-ts/dist/cjs/helpdoc.js").PrintHelp & import("cmd-ts/dist/cjs/helpdoc.js").ProvidesHelp & import("cmd-ts/dist/cjs/helpdoc.js").Named & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned> & import("cmd-ts/dist/cjs/argparser.js").Register & import("cmd-ts/dist/cjs/runner.js").Handling<{
|
|
140
|
+
storageDir: string;
|
|
141
|
+
cdnCacheDir: string;
|
|
142
|
+
s3Bucket: string | undefined;
|
|
143
|
+
s3Endpoint: string | undefined;
|
|
144
|
+
s3Region: string | undefined;
|
|
145
|
+
s3AccessKeyId: string | undefined;
|
|
146
|
+
s3SecretAccessKey: string | undefined;
|
|
147
|
+
s3KeyPrefix: string | undefined;
|
|
148
|
+
s3ForcePathStyle: boolean;
|
|
149
|
+
s3MaxWritesPerSecond: number | undefined;
|
|
150
|
+
databaseUrl: string | undefined;
|
|
151
|
+
listenDatabaseUrl: string | undefined;
|
|
152
|
+
webhooks: string | undefined;
|
|
50
153
|
}, Promise<void>> & {
|
|
51
|
-
run(context:
|
|
52
|
-
} & Partial<
|
|
154
|
+
run(context: import("cmd-ts/dist/cjs/argparser.js").ParseContext): Promise<import("cmd-ts/dist/cjs/argparser.js").ParsingResult<Promise<void>>>;
|
|
155
|
+
} & Partial<import("cmd-ts/dist/cjs/helpdoc.js").Versioned & import("cmd-ts/dist/cjs/helpdoc.js").Descriptive & import("cmd-ts/dist/cjs/helpdoc.js").Aliased>;
|
|
53
156
|
//#endregion
|
|
54
|
-
export {
|
|
157
|
+
export {};
|
|
55
158
|
//# sourceMappingURL=cli.d.mts.map
|
package/dist/cli.d.mts.map
CHANGED
|
@@ -1 +1 @@
|
|
|
1
|
-
{"version":3,"file":"cli.d.mts","names":[],"sources":["../cli.ts"],"mappings":"
|
|
1
|
+
{"version":3,"file":"cli.d.mts","names":[],"sources":["../cli.ts"],"mappings":";qBAkJa,iBAAe,+CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IA2I1B,6CAAA,iDAAA,mDAAA;qBAEW,eAAa,+CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAyCxB,6CAAA,iDAAA,mDAAA;qBAEW,gBAAc,+CAAA;;;;;;;;;;;;IAkBzB,6CAAA,iDAAA,mDAAA;qBAEW,6BAA2B,+CAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAatC,6CAAA,iDAAA,mDAAA"}
|