@microteia/console 2.8.0 → 2.18.0

package/lib/console/installedExtensions.js

@@ -0,0 +1,37 @@
+import { decodeFields, documentId, listDocuments } from './firestoreRest.js';
+export const listTenants = async (projectId) => {
+    const documents = await listDocuments(projectId, '/tenants');
+    return documents
+        .map((document) => {
+        const id = documentId(document);
+        const data = decodeFields(document.fields);
+        return { id, name: typeof data.name === 'string' && data.name !== '' ? data.name : id };
+    })
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+};
+/**
+ * As extensões instaladas num escritório.
+ *
+ * A DESATIVADA vem junto, marcada. Quem decide o que fazer com ela é quem chamou: para o `provision`
+ * ela não exige backend nenhum; para o catálogo ela ainda explica de onde veio uma tela que continua
+ * gravada no banco.
+ */
+export const readInstalledExtensions = async (projectId, tenantId) => {
+    const documents = await listDocuments(projectId, `/tenants/${tenantId}/installed_extensions`);
+    return documents.map((document) => {
+        const data = decodeFields(document.fields);
+        const pkg = data.package;
+        const manifest = pkg?.manifest;
+        const fallbackId = documentId(document);
+        return {
+            tenantId,
+            documentPath: `/tenants/${tenantId}/installed_extensions/${fallbackId}`,
+            id: String(manifest?.id ?? fallbackId),
+            name: String(manifest?.name ?? manifest?.id ?? fallbackId),
+            version: String(manifest?.version ?? '0.0.0'),
+            active: data.active !== false,
+            manifest,
+            data,
+        };
+    });
+};

package/lib/console/loginExtensions.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Este arquivo BLOQUEIA a página: é um `<script>` no `<head>`, antes do bundle. Um pacote gordo aqui
+ * custa em toda visita, inclusive na de quem nem vai entrar. O aviso vem antes de doer, e a recusa
+ * vem quando já dói para todo mundo.
+ */
+export declare const STAMP_WARN_BYTES: number;
+export declare const STAMP_MAX_BYTES: number;
+export declare const STAMP_FILE = "microteia-extensions.js";
+export interface LoginExtensionsResult {
+    /** O conteúdo do arquivo carimbado. Escrito sempre, mesmo vazio — ver `stampLoginExtensions`. */
+    contents: string;
+    /** `id@version` de cada pacote carimbado, na ordem declarada. */
+    stamped: string[];
+    /** O que quem instala precisa saber sem que o deploy pare. */
+    warnings: string[];
+    bytes: number;
+}
+export declare const parseExtensionPaths: (declared: string | null) => string[];
+/**
+ * Monta o carimbo. `preLoginPoints` vem do manifesto do PACOTE do kernel instalado, e não de uma lista
+ * aqui: o Console é versionado separadamente, e uma cópia dela passaria a descrever o contrato de
+ * outra versão em silêncio. Ausente (pacote antigo), a checagem é pulada em vez de inventada.
+ */
+export declare const buildLoginExtensions: (root: string, declared: string | null, preLoginPoints: string[] | undefined) => Promise<LoginExtensionsResult>;
+/**
+ * Escreve o carimbo SEMPRE, inclusive vazio. Pular a escrita quando a lista está vazia deixaria o
+ * carimbo do deploy anterior no ar: tirar um pacote de `login.extensions` não o tiraria da tela.
+ */
+export declare const stampPath: (install: string) => string;

package/lib/console/loginExtensions.js

@@ -0,0 +1,101 @@
+import { readFile } from 'node:fs/promises';
+import { join, resolve } from 'node:path';
+/**
+ * Este arquivo BLOQUEIA a página: é um `<script>` no `<head>`, antes do bundle. Um pacote gordo aqui
+ * custa em toda visita, inclusive na de quem nem vai entrar. O aviso vem antes de doer, e a recusa
+ * vem quando já dói para todo mundo.
+ */
+export const STAMP_WARN_BYTES = 256 * 1024;
+export const STAMP_MAX_BYTES = 1024 * 1024;
+export const STAMP_FILE = 'microteia-extensions.js';
+export const parseExtensionPaths = (declared) => (declared ?? '')
+    .split(',')
+    .map((entry) => entry.trim())
+    .filter((entry) => entry !== '');
+const asStampedPackage = (parsed, path) => {
+    const manifest = parsed?.manifest;
+    if (!manifest || typeof manifest !== 'object') {
+        throw new Error(`${path} is not an extension package: it has no "manifest".`);
+    }
+    const { id, version, contributes } = manifest;
+    if (typeof id !== 'string' || id === '') {
+        throw new Error(`${path} has no "manifest.id".`);
+    }
+    if (typeof version !== 'string' || version === '') {
+        throw new Error(`${path} has no "manifest.version".`);
+    }
+    if (!Array.isArray(contributes)) {
+        throw new Error(`${path} has no "manifest.contributes" array.`);
+    }
+    return parsed;
+};
+/**
+ * Monta o carimbo. `preLoginPoints` vem do manifesto do PACOTE do kernel instalado, e não de uma lista
+ * aqui: o Console é versionado separadamente, e uma cópia dela passaria a descrever o contrato de
+ * outra versão em silêncio. Ausente (pacote antigo), a checagem é pulada em vez de inventada.
+ */
+export const buildLoginExtensions = async (root, declared, preLoginPoints) => {
+    const paths = parseExtensionPaths(declared);
+    const packages = [];
+    const stamped = [];
+    const warnings = [];
+    for (const path of paths) {
+        const absolute = resolve(root, path);
+        let parsed;
+        try {
+            parsed = JSON.parse(await readFile(absolute, 'utf8'));
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                throw new Error(`login.extensions lists ${path}, which does not exist.\n`
+                    + 'Compile the extension first ("microteia-plugin build" inside extensions/), '
+                    + 'or remove the path from microteia.yaml.', { cause: error });
+            }
+            throw new Error(`${path} is not valid JSON.`, { cause: error });
+        }
+        const pkg = asStampedPackage(parsed, path);
+        if (preLoginPoints !== undefined) {
+            const points = pkg.manifest.contributes
+                .map((contribution) => contribution.point)
+                .filter((point) => typeof point === 'string');
+            const effective = points.filter((point) => preLoginPoints.includes(point));
+            if (effective.length === 0) {
+                throw new Error(`${path} (${pkg.manifest.id}) contributes nothing that works before sign-in, so stamping it `
+                    + 'would load it with no effect.\n'
+                    + `  Points that work before sign-in: ${preLoginPoints.join(', ')}.\n`
+                    + `  This package contributes: ${points.length === 0 ? '(none)' : [...new Set(points)].join(', ')}.\n`
+                    + '  To USE it inside the organization, install it from the Extensions screen instead.');
+            }
+        }
+        if (Array.isArray(pkg.views) && pkg.views.length > 0) {
+            warnings.push(`${pkg.manifest.id} ships ${pkg.views.length} view(s): stamped packages load untrusted, `
+                + 'so their code does not run before sign-in — only declarations apply');
+        }
+        const duplicate = packages.find((existing) => existing.manifest.id === pkg.manifest.id);
+        if (duplicate !== undefined) {
+            throw new Error(`login.extensions lists ${pkg.manifest.id} twice. The Kernel would ignore the second one, `
+                + 'so the file says something the installation does not do.');
+        }
+        packages.push(pkg);
+        stamped.push(`${pkg.manifest.id}@${pkg.manifest.version}`);
+    }
+    const contents = `// Generated by "microteia deploy". Do not edit by hand.\n`
+        + `window.__MICROTEIA_EXTENSIONS__ = ${JSON.stringify(packages)};\n`;
+    const bytes = Buffer.byteLength(contents, 'utf8');
+    if (bytes > STAMP_MAX_BYTES) {
+        throw new Error(`The stamped extensions would be ${Math.round(bytes / 1024)} KiB, over the `
+            + `${STAMP_MAX_BYTES / 1024} KiB limit. This file blocks the page on every visit, including `
+            + 'visits by people who never sign in.\n'
+            + '  Keep before-sign-in packages to what the sign-in screen needs, and install the rest.');
+    }
+    if (bytes > STAMP_WARN_BYTES) {
+        warnings.push(`the stamped extensions are ${Math.round(bytes / 1024)} KiB, and this file blocks the page on `
+            + 'every visit');
+    }
+    return { contents, stamped, warnings, bytes };
+};
+/**
+ * Escreve o carimbo SEMPRE, inclusive vazio. Pular a escrita quando a lista está vazia deixaria o
+ * carimbo do deploy anterior no ar: tirar um pacote de `login.extensions` não o tiraria da tela.
+ */
+export const stampPath = (install) => join(install, 'hosting', STAMP_FILE);

package/lib/console/provision.d.ts

@@ -8,6 +8,31 @@ export interface InstalledClaim extends BackendClaim {
     documentPath: string;
     applied: boolean;
 }
+/**
+ * A varredura inteira, e não só o que ela achou.
+ *
+ * As contagens estão aqui porque é delas que sai o direito de APAGAR: a Cloud Function é do PROJETO e a
+ * instalação é do ESCRITÓRIO, então "extensão nenhuma exige mais" é uma afirmação sobre todos os
+ * escritórios do projeto, não sobre o último que foi lido. A varredura é completa ou não existe —
+ * `listDocuments` pagina até o fim e qualquer leitura recusada derruba o comando —, e o que faltava era
+ * DIZER isso a quem lê a proposta de remoção.
+ */
+export interface InstalledSurvey {
+    /** Escritórios lidos. Todos os do projeto, ou nada abaixo teria acontecido. */
+    tenants: number;
+    /** Cópias de extensão lidas, ativas ou não. */
+    extensions: number;
+    claims: InstalledClaim[];
+    /**
+     * Todo id instalado e ativo no projeto, exija ele backend ou não.
+     *
+     * `claims` não serve para esta pergunta, e a diferença é a que faz a function comum ser retirada pelo
+     * motivo certo: uma extensão sem `manifest.backend` nunca vira reivindicação, mas ela pode muito bem
+     * ser uma das que a function comum serve. Decidir pela lista de reivindicações apagaria a function de
+     * quem está instalado.
+     */
+    installedIds: Set<string>;
+}
 /**
  * O que cada escritório do projeto instalou e exige do backend.
  *
@@ -15,8 +40,7 @@ export interface InstalledClaim extends BackendClaim {
  * contra `manifest.functions` antes de qualquer deploy. Nome de function fora do pacote é recusado com
  * explicação; não há injeção possível, porque o código é sempre o do pacote.
  */
-export declare const readInstalledClaims: (projectId: string) => Promise<InstalledClaim[]>;
-export declare const parseAppliedFunctions: (value: string | null) => string[];
+export declare const surveyInstallations: (projectId: string) => Promise<InstalledSurvey>;
 export interface ProvisionOptions {
     projectId: string;
     region: string;
@@ -51,17 +75,6 @@ export interface ProvisionOutcome {
  * divergiriam exatamente no ponto em que ninguém olha.
  */
 export declare const provisionBackend: (options: ProvisionOptions) => Promise<ProvisionOutcome>;
-/**
- * A lista aplicada CONVERGE para o que ainda é exigido: o que já estava e continua sendo pedido, mais
- * o que subiu agora, mais o órfão que não foi removido. Reescrevê-la só com o que subiu NESTA execução
- * a esvaziava na segunda passada — e a terceira redeployava tudo, achando que nada havia sido feito.
- */
-export declare const appliedAfterRun: (input: {
-    alreadyApplied: string[];
-    wanted: string[];
-    deployed: string[];
-    keptOrphans: string[];
-}) => string[];
 /**
  * A impressão digital do parâmetro só avança quando TODAS as functions que o carregam subiram. Gravar
  * antes disso é o que transformaria uma falha de deploy em silêncio permanente: o valor novo ficaria