@xano/cli 1.1.0 → 1.3.0

package/dist/utils/microservice-wait.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Poll a tenant's microservice deployment status until every auto-deployed
+ * microservice settles (ok/error) or a timeout elapses. Backs `ephemeral push
+ * --wait`: after a multidoc push auto-deploys microservices (tenant_deploy=
+ * "auto"), the CLI waits here for them to become Ready and reports the outcome.
+ *
+ * The backend route (GET .../tenant/{name}/microservice, statement
+ * mvp:microservice_status_all) returns one entry per microservice with a live
+ * k8s readiness read. `manual`/`disabled` microservices are reported but not
+ * waited on (they were never deployed by the push).
+ */
+/** One microservice's status as returned by the tenant status route. */
+export interface MicroserviceStatusEntry {
+    desired?: number;
+    detail?: string;
+    microservice_id: number;
+    name: string;
+    ready?: number;
+    status: string;
+    tenant_deploy?: string;
+}
+export interface WaitOptions {
+    /** Bearer token for the authed status GET. */
+    accessToken: string;
+    /** Called once per poll with the latest entries, for progress rendering. */
+    onPoll?: (entries: MicroserviceStatusEntry[], elapsedMs: number) => void;
+    /** Poll cadence in ms (default 2000). */
+    pollIntervalMs?: number;
+    /** Absolute URL of the tenant microservice status route. */
+    statusUrl: string;
+    /** Overall wait budget in ms (default 300000 = 300s). */
+    timeoutMs?: number;
+    /** Verbose request logging passthrough. */
+    verbose?: boolean;
+    /** Authed fetch (command.verboseFetch bound), so TLS/dispatcher settings apply. */
+    verboseFetch: (url: string, options: RequestInit, verbose: boolean, authToken?: string) => Promise<Response>;
+}
+export interface WaitResult {
+    /** The final status entries observed. */
+    entries: MicroserviceStatusEntry[];
+    /** True if any awaited (auto) microservice ended in "error". */
+    hadError: boolean;
+    /** True if the wait budget elapsed before all awaited microservices settled. */
+    timedOut: boolean;
+}
+/** An awaited microservice is one that was auto-deployed and is not skipped/disabled. */
+export declare function isAwaited(entry: MicroserviceStatusEntry): boolean;
+/**
+ * Poll until all awaited microservices settle or the timeout elapses. Transient
+ * poll failures (network blips, a brief 5xx while a pod restarts) are tolerated —
+ * they don't abort the wait; only the overall timeout does.
+ */
+export declare function waitForMicroservices(opts: WaitOptions): Promise<WaitResult>;

package/dist/utils/microservice-wait.js

@@ -0,0 +1,84 @@
+/**
+ * Poll a tenant's microservice deployment status until every auto-deployed
+ * microservice settles (ok/error) or a timeout elapses. Backs `ephemeral push
+ * --wait`: after a multidoc push auto-deploys microservices (tenant_deploy=
+ * "auto"), the CLI waits here for them to become Ready and reports the outcome.
+ *
+ * The backend route (GET .../tenant/{name}/microservice, statement
+ * mvp:microservice_status_all) returns one entry per microservice with a live
+ * k8s readiness read. `manual`/`disabled` microservices are reported but not
+ * waited on (they were never deployed by the push).
+ */
+/** Statuses that mean an awaited microservice has settled (no longer in flight). */
+const SETTLED = new Set(['error', 'ok']);
+/** Statuses that mean we don't wait on this microservice at all. */
+const NOT_AWAITED = new Set(['disabled', 'skipped']);
+const sleep = (ms) => new Promise((r) => {
+    setTimeout(r, ms);
+});
+/** An awaited microservice is one that was auto-deployed and is not skipped/disabled. */
+export function isAwaited(entry) {
+    return !NOT_AWAITED.has(entry.status) && (entry.tenant_deploy ?? 'auto') !== 'manual';
+}
+/** True once every awaited microservice has settled (ok/error). */
+function allSettled(entries) {
+    const awaited = entries.filter((e) => isAwaited(e));
+    // No auto microservices at all → nothing to wait for.
+    if (awaited.length === 0)
+        return true;
+    return awaited.every((e) => SETTLED.has(e.status));
+}
+/**
+ * Fetch the status route once. Throws on a non-2xx so the caller can decide
+ * whether a transient failure is fatal (it isn't — we keep polling).
+ */
+async function fetchStatus(opts) {
+    const res = await opts.verboseFetch(opts.statusUrl, { headers: { Authorization: `Bearer ${opts.accessToken}` }, method: 'GET' }, opts.verbose ?? false, opts.accessToken);
+    if (!res.ok) {
+        throw new Error(`status ${res.status} ${res.statusText}`);
+    }
+    const body = (await res.json());
+    if (!Array.isArray(body)) {
+        throw new TypeError('unexpected status response shape');
+    }
+    return body;
+}
+/**
+ * Poll until all awaited microservices settle or the timeout elapses. Transient
+ * poll failures (network blips, a brief 5xx while a pod restarts) are tolerated —
+ * they don't abort the wait; only the overall timeout does.
+ */
+export async function waitForMicroservices(opts) {
+    const pollIntervalMs = opts.pollIntervalMs ?? 2000;
+    const timeoutMs = opts.timeoutMs ?? 300_000;
+    const start = Date.now();
+    let entries = [];
+    // Poll loop. We always do at least one fetch so `--wait` reports even when the
+    // deployment already settled between the push returning and the first poll.
+    for (;;) {
+        const elapsed = Date.now() - start;
+        try {
+            // eslint-disable-next-line no-await-in-loop -- polling is sequential by design
+            entries = await fetchStatus(opts);
+            opts.onPoll?.(entries, elapsed);
+            if (allSettled(entries)) {
+                return { entries, hadError: entries.some((e) => isAwaited(e) && e.status === 'error'), timedOut: false };
+            }
+        }
+        catch {
+            // A transient status read failure is non-fatal — keep polling until the
+            // overall timeout. There is deliberately no consecutive-failure cap: we
+            // don't surface each blip, and the timeout is the only failure signal.
+        }
+        if (Date.now() - start + pollIntervalMs > timeoutMs) {
+            // Out of budget. Report whatever we last saw as timed out.
+            return {
+                entries,
+                hadError: entries.some((e) => isAwaited(e) && e.status === 'error'),
+                timedOut: true,
+            };
+        }
+        // eslint-disable-next-line no-await-in-loop -- pacing the poll loop is the point
+        await sleep(pollIntervalMs);
+    }
+}

package/dist/utils/multidoc-push.d.ts

@@ -89,7 +89,61 @@ export declare function collectFiles(dir: string): string[];
  * Apply include/exclude glob filters to a file list. Logs filter results.
  * Returns the filtered file list.
  */
+/**
+ * Normalize a filter pattern into one minimatch can actually match against a
+ * repo-relative FILE path.
+ *
+ * minimatch has no notion of "this pattern names a directory", and the two
+ * spellings a person reaches for first both silently match NOTHING:
+ *
+ *   "table/"  a trailing slash is not directory syntax; it matches nothing
+ *   "table"   no slash, so `matchBase` compares it to the file's BASENAME,
+ *             i.e. it asks "is this file called `table`", not "is it under
+ *             `table/`"
+ *
+ * Silently matching nothing is the dangerous half of this: combined with
+ * `--delete`, a filter that fails open pushes more than intended, and a filter
+ * that succeeds deletes what it was meant to protect. So a pattern that names a
+ * real directory is expanded to `<dir>/**` rather than left to match nothing.
+ */
+export declare function normalizeFilterPattern(pattern: string, inputDir: string): string;
 export declare function applyFilters(files: string[], inputDir: string, include: string[] | undefined, exclude: string[] | undefined, log: (msg: string) => void): string[];
+/** A document the filter removed from the push, and therefore must protect. */
+export interface FilteredOutDocument {
+    guid?: string;
+    key: string;
+    name: string;
+    relPath: string;
+    type: string;
+}
+/**
+ * Describe the documents a --include/--exclude filter removed.
+ *
+ * These are the objects the user asked NOT to touch, and they are exactly the
+ * ones a `--delete` sweep would remove: a filtered-out document never reaches
+ * the payload, so the server reads it as deleted from the tree. Their GUIDs are
+ * sent as `protect_guids` so the server spares them, and their keys are used to
+ * VERIFY the server actually did.
+ */
+export declare function describeFilteredOut(allFiles: string[], keptFiles: string[], inputDir: string): FilteredOutDocument[];
+/**
+ * Delete operations that would remove something the filter excluded.
+ *
+ * This is the guard's actual test, and it is deliberately performed against the
+ * dry-run the SERVER returned rather than trusting that `protect_guids` was
+ * honoured: an older instance ignores the parameter entirely, and a document
+ * with no GUID cannot be protected at all. Either way the answer here is the
+ * truth about what the push is about to do.
+ */
+export declare function deletesHittingFilteredOut(operations: Array<{
+    action: string;
+    name: string;
+    type: string;
+}>, filteredOut: FilteredOutDocument[]): Array<{
+    name: string;
+    relPath: string;
+    type: string;
+}>;
 /**
  * Read .xs files into document entries, skipping empty files.
  */
@@ -97,6 +151,40 @@ export declare function readDocuments(files: string[]): Array<{
     content: string;
     filePath: string;
 }>;
+/**
+ * Return the entries whose file holds more than one document (a `---`
+ * separator). Used to refuse multi-doc files before the push pipeline's
+ * single-doc-per-file assumptions can drop or corrupt them.
+ */
+export declare function findMultiDocEntries(entries: Array<{
+    content: string;
+    filePath: string;
+}>): Array<{
+    count: number;
+    filePath: string;
+}>;
+/**
+ * Return every `workspace` document in the push set, with the name it declares.
+ *
+ * A tree must carry at most ONE. The server applies the first workspace
+ * document it encounters to the workspace being pushed into and silently
+ * discards the rest, with no check that the document actually describes that
+ * workspace — so a second one renames the destination to a foreign name while
+ * leaving its content untouched, and which name wins flips with the contents of
+ * the pushed set.
+ *
+ * Trees accumulate a second one easily, because `pull` names the file after the
+ * workspace's own name (`workspace/{name}.xs`): pulling a different workspace
+ * into the same directory ADDS a file rather than overwriting, and renaming a
+ * workspace leaves the old-name file behind.
+ */
+export declare function findWorkspaceEntries(entries: Array<{
+    content: string;
+    filePath: string;
+}>): Array<{
+    filePath: string;
+    name: string;
+}>;
 export declare function renderBadReferences(badRefs: BadReference[], log: (msg: string) => void): void;
 export declare function renderBadIndexes(badIndexes: BadIndex[], log: (msg: string) => void): void;
 export declare function confirm(message: string): Promise<boolean>;