primitive-admin 1.1.0-alpha.49 → 1.1.0-alpha.50

package/dist/src/commands/sync.d.ts

@@ -247,6 +247,45 @@ export declare function rewriteWorkflowSchemasToNative(rawToml: string, workflow
 };
 export declare function serializeWorkflow(workflow: any, draft: any, configs: any[], logger?: (message: string) => void): string;
 export declare function serializeGroupTypeConfig(config: any, ruleSetIdToName: Map<string, string>): string;
+/**
+ * Issue #1567 — the TOML-owned scalar fields of a database-type config.
+ *
+ * These are fields the `database-types/*.toml` file OWNS: the local file is the
+ * source of truth, so removing one from the TOML must clear it server-side
+ * (config-as-code), not silently preserve the stale value. `schema` is NOT in
+ * this list — it keeps its own `hasSchema` prior-state discriminator, since a
+ * schema is a large sub-tree, not a scalar.
+ */
+export declare const DB_TYPE_OWNED_SCALARS: readonly ["ruleSetId", "triggers", "metadataAccess", "defaultAccess", "autoPopulatedFields", "timestamps", "metadataManifest"];
+/** The user-facing TOML key for a wire field (for push output). */
+export declare function dbTypeFieldLabel(key: string): string;
+/**
+ * True when a value carries real content. null/undefined, blank/whitespace
+ * strings, and empty objects/arrays all count as "no value" — the same
+ * normalization the server applies (`value || null`) when it decides whether a
+ * field is set.
+ */
+export declare function hasMeaningfulValue(v: any): boolean;
+/**
+ * Issue #1567 — always-send owned db-type scalars as value-or-`null`.
+ *
+ * The server PATCH endpoint distinguishes an omitted key (preserve) from an
+ * explicit `null` (clear), so sending every owned scalar as `value ?? null`
+ * converges the server to the local TOML: a field removed from the file lands
+ * as `null` and is cleared. Matches the always-send pattern the sibling
+ * `collection-type-config` push already uses.
+ */
+export declare function buildOwnedScalarUpdate(typeConfig: any): Record<string, any>;
+/**
+ * Issue #1567 — the owned scalars this push genuinely clears: the outgoing
+ * value is empty but the server currently holds a real value (a non-null →
+ * null transition). Used for the "Cleared <field>" report so removing an
+ * access gate is never silent, and to decide whether an otherwise
+ * type-field-less push still needs a type-config PATCH. Returns wire field
+ * names (map with `dbTypeFieldLabel` for output). `serverConfig` is the live
+ * GET; without it (fresh type or a failed fetch) nothing is reported cleared.
+ */
+export declare function ownedScalarsBeingCleared(updateData: Record<string, any>, serverConfig: any): string[];
 export declare function parseDatabaseTypeToml(tomlData: any): {
     typeConfig: any;
     operations: any[];
@@ -254,6 +293,17 @@ export declare function parseDatabaseTypeToml(tomlData: any): {
 };
 export declare function parseGroupTypeConfigToml(tomlData: any): any;
 export declare function parseCollectionTypeConfigToml(tomlData: any): any;
+export declare function hashLocalRuleSetForDiff(parsedToml: any): string;
+export declare function hashRemoteRuleSetForDiff(ruleSet: any): string;
+export declare function hashLocalGroupTypeConfigForDiff(parsedToml: any, ruleSetNameToId: Map<string, string>): string;
+export declare function hashRemoteGroupTypeConfigForDiff(config: any, ruleSetIdToName: Map<string, string>, ruleSetNameToId: Map<string, string>): string;
+export declare function hashLocalCollectionTypeConfigForDiff(parsedToml: any, ruleSetNameToId: Map<string, string>): string;
+export declare function hashRemoteCollectionTypeConfigForDiff(config: any, ruleSetIdToName: Map<string, string>, ruleSetNameToId: Map<string, string>): string;
+export declare function hashLocalDatabaseTypeForDiff(parsedToml: any, ruleSetNameToId: Map<string, string>): string;
+export declare function hashRemoteDatabaseTypeForDiff(typeConfig: any, operations: any[], subscriptions: any[], ruleSetIdToName: Map<string, string>, ruleSetNameToId: Map<string, string>): string;
+export declare function hashLocalMetadataCategoryForDiff(parsedToml: any): string;
+export declare function hashRemoteMetadataCategoryForDiff(config: any): string;
+export declare function parseTomlFile(filePath: string): any;
 /**
  * Paginate through a list endpoint, collecting all items.
  */
@@ -264,6 +314,54 @@ export declare function fetchAll<T>(listFn: (params: {
     items: T[];
     nextCursor?: string | null;
 }>, pageSize?: number, maxPages?: number): Promise<T[]>;
+/**
+ * Issue #976 / #1006: shared 409 → adopt-by-key recovery for `sync push`
+ * create paths. When a CREATE hits a per-app unique-key constraint, the resource
+ * is already on the server but missing from local sync state: orphaned by a
+ * prior push that aborted before recording it, a mid-apply crash, or an
+ * out-of-band create with the same key. Rather than hard-fail forever, this
+ * helper looks the resource up by its unique key and hands the matched item
+ * back so the caller can re-issue the create as an UPDATE and converge.
+ *
+ * The conflict surfaces inconsistently across create routes, so detection is
+ * deliberately broad (see `isConflict` below):
+ *   - a 409 status (webhooks, cron triggers, the standard case);
+ *   - an "already exists" message — some routes surface the 409 as HTTP 400,
+ *     e.g. workflows;
+ *   - a "must be unique" message — routes with no explicit conflict catch let
+ *     dynamo-bao's per-app unique-constraint error propagate verbatim (e.g. rule
+ *     sets, whose create route has no 409 translation). This matches the
+ *     server's own admin-api convention (`src/admin-api.ts`), which treats
+ *     "must be unique" as a duplicate-key conflict.
+ * Any other error is NOT a conflict and re-throws unchanged (see below).
+ *
+ * Safety (load-bearing): exact-key match only. The `lookup` is app-scoped, so a
+ * key match is also an ownership match — an unrelated resource is never
+ * overwritten. The three non-adopt outcomes each surface a clear error and do
+ * NOT touch the server:
+ *   - a non-409 create error is re-wrapped via `wrapEntityError` and re-thrown
+ *     (no lookup is attempted);
+ *   - a lookup failure throws a clear "already exists but could not be adopted
+ *     (lookup failed: …)";
+ *   - a 409 with no matching key re-throws the ORIGINAL create error rather
+ *     than silently proceeding.
+ *
+ * Pagination is the caller's concern: `lookup` must return the COMPLETE
+ * candidate set. For cursor-based lists (webhooks, integrations, prompts,
+ * workflows) wrap the list call in `fetchAll`; the cron-triggers route already
+ * drains every page server-side (#1668) so its flat `{ items }` is complete.
+ * The UPDATE re-issue and sync-state stamping stay with the caller because they
+ * differ per entity.
+ *
+ * @returns the matched existing item (guaranteed non-null on return).
+ */
+export declare function adoptByKeyOnCreate409<T>(opts: {
+    err: unknown;
+    kind: string;
+    key: string;
+    lookup: () => Promise<T[]>;
+    matchKey: (item: T) => boolean;
+}): Promise<T>;
 /**
  * Resolve a key-based rule set name reference to an ID.
  * Throws if the name cannot be resolved and throwOnMissing is true.