primitive-admin 1.0.50 → 1.0.51

package/dist/src/commands/sync.js

@@ -12,6 +12,7 @@ import { createSnapshot, listSnapshots, resolveSnapshot, restoreSnapshot, pruneS
 import { validateWorkflowToml, formatWorkflowTomlErrors, } from "../lib/workflow-toml-validator.js";
 import { expandWorkflowTomlData } from "../lib/workflow-fragments.js";
 import { success, error, info, warn, keyValue, json, divider, } from "../lib/output.js";
+import { confirmPrompt } from "../lib/confirm-prompt.js";
 import chalk from "chalk";
 function ensureDir(dirPath) {
     if (!existsSync(dirPath)) {
@@ -260,7 +261,13 @@ function serializeBlobBucket(bucket) {
             name: bucket.name,
             description: bucket.description || undefined,
             ttlTier: bucket.ttlTier,
-            accessPolicy: bucket.accessPolicy,
+            // #1020: `preset` is the honest key; a custom bucket carries ruleSetId
+            // instead. Omit preset for custom buckets (preset === "custom").
+            preset: bucket.preset && bucket.preset !== "custom"
+                ? bucket.preset
+                : bucket.ruleSetId
+                    ? undefined
+                    : bucket.preset,
         },
     };
     if (bucket.ruleSetId) {
@@ -313,6 +320,9 @@ function serializeWorkflow(workflow, draft, configs) {
             status: workflow.status,
             activeConfigName: activeConfigName,
             accessRule: workflow.accessRule || undefined,
+            // #1081 — workflow principal mode. Emit only when set so a fresh
+            // pull → push round-trips it without writing a noisy `runAs = ""`.
+            runAs: workflow.runAs || undefined,
             perUserMaxRunning: workflow.perUserMaxRunning,
             perUserMaxQueued: workflow.perUserMaxQueued,
             dequeueOrder: workflow.dequeueOrder,
@@ -734,56 +744,6 @@ export async function pullScripts(client, appId, configDir, logger = () => { })
     }
     return { scriptEntities, count: items.length };
 }
-/**
- * Issue #973 — format the "stale referencing workflows" warning for a script
- * push. Pure (no I/O) so it can be unit-tested directly.
- *
- * `staleWorkflows` is the server's report of active workflows whose frozen
- * snapshot still pins a DIFFERENT (old) body hash for `scriptName` — i.e. the
- * workflows that will keep running the previous script body until republished.
- * Returns `null` when nothing is stale (no warning to print). When `dryRun` is
- * true the wording reflects that nothing was mutated yet.
- */
-export function formatStaleWorkflowsWarning(scriptName, staleWorkflows, dryRun = false) {
-    if (!staleWorkflows || staleWorkflows.length === 0)
-        return null;
-    const labels = staleWorkflows.map((w) => w.workflowKey || w.name || "(unknown workflow)");
-    const count = labels.length;
-    const noun = count === 1 ? "workflow" : "workflows";
-    const verb = dryRun ? "would still run" : "still run";
-    return (`Script "${scriptName}" ${dryRun ? "would be updated" : "updated"}, but ` +
-        `${count} ${noun} ${verb} the previous body until re-pushed: ` +
-        `${labels.join(", ")}. ` +
-        `Re-push (or republish) ${count === 1 ? "it" : "them"} to pick up the change ` +
-        `(the run path reads each workflow's frozen snapshot, not the live script).`);
-}
-/**
- * Issue #973 — query the server for active workflows left stale by a script
- * push and print a warning naming them. Best-effort: a missing route (older
- * server) or any transport error is swallowed so it never fails the sync.
- *
- * `contentHash` is the body hash being pushed (the server's authoritative hash
- * after a real push, or the locally-computed would-be hash for `--dry-run`).
- */
-async function warnStaleWorkflowsForScript(client, appId, scriptId, contentHash, dryRun) {
-    let report;
-    try {
-        report = await client.getStaleWorkflowsForScript(appId, scriptId, contentHash);
-    }
-    catch {
-        // Older server without the route, or a transient failure — staleness
-        // info is advisory, so we stay silent rather than break the push.
-        return;
-    }
-    const message = formatStaleWorkflowsWarning(report.scriptName, report.staleWorkflows, dryRun);
-    if (message) {
-        warn(`  ${message}`);
-    }
-}
-/** SHA-256 hex of a string body, matching the server's script `contentHash`. */
-function sha256HexString(body) {
-    return createHash("sha256").update(body, "utf-8").digest("hex");
-}
 async function pullTestCasesForBlock(client, appId, blockType, blockId, blockKey, configDir, testCaseEntities, lookupMaps) {
     let testCases;
     try {
@@ -2273,8 +2233,29 @@ Directory Structure:
                         continue;
                     }
                     if (existingId) {
-                        // Blob buckets don't have an update API - skip if already exists
-                        info(`  Blob bucket already exists, skipping: ${key}`);
+                        // #1020 (D8): idempotently apply preset/ruleSet/name/description
+                        // changes via PATCH. bucketKey/ttlTier are immutable and not sent.
+                        const updatePayload = {};
+                        if (bucket.preset)
+                            updatePayload.preset = bucket.preset;
+                        else if (bucket.accessPolicy)
+                            updatePayload.accessPolicy = bucket.accessPolicy;
+                        if (bucket.ruleSetId)
+                            updatePayload.ruleSetId = bucket.ruleSetId;
+                        if (bucket.name)
+                            updatePayload.name = bucket.name;
+                        if (bucket.description !== undefined)
+                            updatePayload.description = bucket.description || null;
+                        changes.push({ type: "blob-bucket", action: "update", key });
+                        if (!options.dryRun) {
+                            try {
+                                await client.updateBlobBucket(resolvedAppId, existingId, updatePayload);
+                                info(`  Updated blob bucket: ${key}`);
+                            }
+                            catch (err) {
+                                warn(`  Failed to update blob bucket ${key}: ${String(err?.message || err)}`);
+                            }
+                        }
                         if (syncState?.entities?.blobBuckets?.[key]) {
                             syncState.entities.blobBuckets[key].contentHash = computeFileHash(filePath);
                         }
@@ -2284,8 +2265,11 @@ Directory Structure:
                             bucketKey: key,
                             name: bucket.name || key,
                             ttlTier: bucket.ttlTier,
-                            accessPolicy: bucket.accessPolicy,
                         };
+                        if (bucket.preset)
+                            payload.preset = bucket.preset;
+                        else if (bucket.accessPolicy)
+                            payload.accessPolicy = bucket.accessPolicy;
                         if (bucket.description)
                             payload.description = bucket.description;
                         if (bucket.ruleSetId)
@@ -2578,7 +2562,10 @@ Directory Structure:
                         changes.push({ type: "script", action: "update", key: name });
                         if (!options.dryRun) {
                             try {
-                                const updated = await client.updateScript(resolvedAppId, existingId, { body });
+                                // #1000 — push a new ScriptConfig + activate it. Referencing
+                                // workflows pick up the new body on their next run (no
+                                // fan-out, no re-push needed).
+                                await client.pushScriptBody(resolvedAppId, existingId, body);
                                 info(`  Updated script: ${name}`);
                                 if (syncState) {
                                     if (!syncState.entities.scripts) {
@@ -2586,24 +2573,16 @@ Directory Structure:
                                     }
                                     syncState.entities.scripts[name] = {
                                         id: existingId,
-                                        modifiedAt: updated?.modifiedAt ||
-                                            syncState.entities.scripts[name]?.modifiedAt ||
+                                        modifiedAt: syncState.entities.scripts[name]?.modifiedAt ||
                                             new Date().toISOString(),
                                         contentHash: computeFileHash(filePath),
                                     };
                                 }
-                                // Issue #973 — warn if active workflows still pin the OLD
-                                // body. Use the server's authoritative post-push hash.
-                                await warnStaleWorkflowsForScript(client, resolvedAppId, existingId, updated?.contentHash || sha256HexString(body), false);
                             }
                             catch (err) {
                                 throw wrapEntityError(err, "update", "script", name);
                             }
                         }
-                        else {
-                            // Dry-run: surface the would-be stale set without mutating.
-                            await warnStaleWorkflowsForScript(client, resolvedAppId, existingId, sha256HexString(body), true);
-                        }
                     }
                     else {
                         // No id in local state — could be brand new OR could be
@@ -2616,7 +2595,7 @@ Directory Structure:
                             changes.push({ type: "script", action: "update", key: name });
                             if (!options.dryRun) {
                                 try {
-                                    const updated = await client.updateScript(resolvedAppId, match.scriptId, { body });
+                                    await client.pushScriptBody(resolvedAppId, match.scriptId, body);
                                     info(`  Updated script: ${name} (adopted from server)`);
                                     if (syncState) {
                                         if (!syncState.entities.scripts) {
@@ -2624,21 +2603,15 @@ Directory Structure:
                                         }
                                         syncState.entities.scripts[name] = {
                                             id: match.scriptId,
-                                            modifiedAt: updated?.modifiedAt || new Date().toISOString(),
+                                            modifiedAt: new Date().toISOString(),
                                             contentHash: computeFileHash(filePath),
                                         };
                                     }
-                                    // Issue #973 — same staleness warning on the adopt path.
-                                    await warnStaleWorkflowsForScript(client, resolvedAppId, match.scriptId, updated?.contentHash || sha256HexString(body), false);
                                 }
                                 catch (err) {
                                     throw wrapEntityError(err, "update", "script", name);
                                 }
                             }
-                            else {
-                                // Dry-run on the adopt path.
-                                await warnStaleWorkflowsForScript(client, resolvedAppId, match.scriptId, sha256HexString(body), true);
-                            }
                         }
                         else {
                             changes.push({ type: "script", action: "create", key: name });
@@ -2738,6 +2711,10 @@ Directory Structure:
                                     description: workflow.description,
                                     status: workflow.status,
                                     accessRule: workflow.accessRule !== undefined ? (workflow.accessRule || null) : undefined,
+                                    // #1081 — workflow principal mode. Absent key → undefined
+                                    // (server leaves it untouched); explicit value/empty is
+                                    // forwarded so it round-trips.
+                                    runAs: workflow.runAs !== undefined ? (workflow.runAs || null) : undefined,
                                     perUserMaxRunning: workflow.perUserMaxRunning,
                                     perUserMaxQueued: workflow.perUserMaxQueued,
                                     dequeueOrder: workflow.dequeueOrder,
@@ -2832,6 +2809,8 @@ Directory Structure:
                                     inputSchema: workflow.inputSchema ? safeJsonParse(workflow.inputSchema) : undefined,
                                     outputSchema: workflow.outputSchema ? safeJsonParse(workflow.outputSchema) : undefined,
                                     accessRule: workflow.accessRule || undefined,
+                                    // #1081 — workflow principal mode (absent → server default).
+                                    runAs: workflow.runAs || undefined,
                                     perUserMaxRunning: workflow.perUserMaxRunning,
                                     perUserMaxQueued: workflow.perUserMaxQueued,
                                     dequeueOrder: workflow.dequeueOrder,
@@ -2946,6 +2925,15 @@ Directory Structure:
                             `\nAborting push: ${validation.errors.length} unresolved $params reference(s) in ${file}.`);
                     }
                     const existingEntry = syncState?.entities?.databaseTypes?.[dbType];
+                    // Issue #915 (defect b): track whether the apply path rejected any
+                    // op for THIS file via the schema gate (OperationRefError /
+                    // SchemaRequiredError). On a non-transactional fresh-type push the
+                    // db-type lands but the bad op is blocked and the loop continues; if
+                    // we then wrote the file-level contentHash, the next push's
+                    // `shouldPushFile` would short-circuit and the missing op would be
+                    // invisible drift. When this flag is set we skip the contentHash
+                    // write so the drift stays visible and a corrected re-push converges.
+                    let fileHadGateRejectedOp = false;
                     // Skip if file hasn't changed since last sync
                     if (!options.force && existingEntry && !shouldPushFile(filePath, existingEntry.contentHash)) {
                         skippedCount++;
@@ -3032,8 +3020,7 @@ Directory Structure:
                         }
                         // 2. Op-edit gate (op create/update dry-run) for every op in the
                         //    TOML. The server runs `runSchemaGate` and short-circuits
-                        //    before persisting. Skipped for a fresh type (no schema on the
-                        //    server yet → gate is a no-op anyway).
+                        //    before persisting.
                         //
                         //    The op gate is run against the schema THIS push is landing
                         //    (`schemaOverride`), not the stale stored schema — the real
@@ -3043,11 +3030,36 @@ Directory Structure:
                         //    a schema landed earlier in the same push"). When the push
                         //    isn't changing the schema, leave the override unset so the
                         //    server uses the stored schema.
-                        if (existingEntry) {
-                            const validateUpdateData = computeTypeUpdateData();
-                            const proposedSchema = "schema" in validateUpdateData
-                                ? validateUpdateData.schema
-                                : undefined;
+                        //
+                        //    Issue #915 (defect a): this gate now runs for FRESH types too
+                        //    (previously guarded by `if (existingEntry)`). For a brand-new
+                        //    db-type the server has no stored config, so we gate the op
+                        //    against the PROPOSED local schema via `schemaOverride`. The
+                        //    server's op-create dry-run accepts a missing type when a
+                        //    `schemaOverride` is present (see
+                        //    database-type-operations-controller.ts). A fresh schemaless
+                        //    type (#666 bootstrap) sends an empty/absent override, and
+                        //    `runSchemaGate` is a no-op without a schema — so that path
+                        //    still succeeds.
+                        {
+                            const localHasSchema = typeof typeConfig.schema === "string" &&
+                                typeConfig.schema.trim().length > 0;
+                            let proposedSchema;
+                            if (existingEntry) {
+                                const validateUpdateData = computeTypeUpdateData();
+                                proposedSchema =
+                                    "schema" in validateUpdateData
+                                        ? validateUpdateData.schema
+                                        : undefined;
+                            }
+                            else {
+                                // Fresh type: the proposed schema is whatever the local TOML
+                                // declares. A schemaless fresh type (no `[models.*]`) sends an
+                                // empty-string override so the server takes the no-schema =
+                                // no-op gate path rather than falling back to a (nonexistent)
+                                // stored config — keeping the #666 bootstrap convergent.
+                                proposedSchema = localHasSchema ? typeConfig.schema : "";
+                            }
                             for (const op of operations) {
                                 const existingOp = existingOpsForType[op.name];
                                 opGateContext = {
@@ -3071,7 +3083,20 @@ Directory Structure:
                                         access: op.access,
                                         definition: op.definition,
                                         params: op.params,
-                                    }, { dryRun: true, schemaOverride: proposedSchema });
+                                    }, {
+                                        dryRun: true,
+                                        schemaOverride: proposedSchema,
+                                        // Issue #915 (defect a, follow-up): for a fresh type the
+                                        // server has no stored config to read `defaultAccess`
+                                        // from, so an op that omits `access` to inherit the
+                                        // TOML-declared type-level `defaultAccess` would be
+                                        // falsely rejected. Thread the proposed value so the
+                                        // fresh-type dry-run gates the same way the real push
+                                        // (which lands the type first) will.
+                                        defaultAccess: typeof typeConfig.defaultAccess === "string"
+                                            ? typeConfig.defaultAccess
+                                            : undefined,
+                                    });
                                 }
                             }
                             // Every op gate passed; clear the context so a later (non-op)
@@ -3563,6 +3588,10 @@ Directory Structure:
                                             key: `${dbType}/${op.name}`,
                                             message: err.message,
                                         });
+                                        // Issue #915 (defect b): a gate-rejected op means this
+                                        // file's state did NOT fully land — don't poison the
+                                        // content hash (see the contentHash write below).
+                                        fileHadGateRejectedOp = true;
                                     }
                                     else if (err instanceof OperationRefError) {
                                         schemaErrors.opRefs.push({
@@ -3571,6 +3600,7 @@ Directory Structure:
                                             refs: err.refs,
                                             message: err.message,
                                         });
+                                        fileHadGateRejectedOp = true;
                                     }
                                     else {
                                         throw wrapEntityError(err, "update", "operation", `${dbType}/${op.name}`);
@@ -3608,6 +3638,10 @@ Directory Structure:
                                             key: `${dbType}/${op.name}`,
                                             message: err.message,
                                         });
+                                        // Issue #915 (defect b): a gate-rejected op means this
+                                        // file's state did NOT fully land — don't poison the
+                                        // content hash (see the contentHash write below).
+                                        fileHadGateRejectedOp = true;
                                     }
                                     else if (err instanceof OperationRefError) {
                                         schemaErrors.opRefs.push({
@@ -3616,6 +3650,7 @@ Directory Structure:
                                             refs: err.refs,
                                             message: err.message,
                                         });
+                                        fileHadGateRejectedOp = true;
                                     }
                                     else {
                                         throw wrapEntityError(err, "create", "operation", `${dbType}/${op.name}`);
@@ -3747,9 +3782,27 @@ Directory Structure:
                     // file. Recompute here so a truly-unchanged subsequent push skips
                     // the whole file via `shouldPushFile`. `--force` bypasses that
                     // skip, so forced re-pushes are unaffected.
+                    //
+                    // Issue #915 (defect b): when the gate rejected an op for this
+                    // file, do NOT record a matching content hash. The db-type itself
+                    // may have been created (the push is non-transactional), but the
+                    // blocked op never landed — a matching hash would make
+                    // `shouldPushFile` short-circuit the next push and hide the missing
+                    // op as "in sync". Clear the hash instead of writing it: an empty
+                    // hash forces `shouldPushFile` to re-evaluate the file, so a
+                    // subsequent `sync push --dry-run` still surfaces the op as drift
+                    // and a corrected re-push converges without manual file edits. We
+                    // clear (rather than merely skip) so the fresh-type create path's
+                    // earlier optimistic hash write (see `createDatabaseTypeConfig`
+                    // above) is also invalidated.
                     if (!options.dryRun && syncState?.entities?.databaseTypes?.[dbType]) {
-                        syncState.entities.databaseTypes[dbType].contentHash =
-                            computeFileHash(filePath);
+                        if (fileHadGateRejectedOp) {
+                            syncState.entities.databaseTypes[dbType].contentHash = "";
+                        }
+                        else {
+                            syncState.entities.databaseTypes[dbType].contentHash =
+                                computeFileHash(filePath);
+                        }
                     }
                 }
             }
@@ -4572,15 +4625,14 @@ Directory Structure:
                 warn(`You have uncommitted git changes under ${configDir}. ` +
                     "Reverting will overwrite them.");
             }
-            const inquirer = await import("inquirer");
-            const { confirm } = await inquirer.default.prompt([
-                {
-                    type: "confirm",
-                    name: "confirm",
-                    message: `Restore snapshot ${target.id} into ${configDir}? This overwrites the current sync directory.`,
-                    default: false,
-                },
-            ]);
+            let confirm;
+            try {
+                confirm = await confirmPrompt(`Restore snapshot ${target.id} into ${configDir}? This overwrites the current sync directory.`);
+            }
+            catch (err) {
+                error(err.message);
+                process.exit(1);
+            }
             if (!confirm) {
                 info("Cancelled.");
                 return;