@payloadcms/figma 0.1.0-alpha.3 → 0.1.0-alpha.4

package/dist/commands/prompt-to-create-project/get-default-project-name.js

@@ -0,0 +1,13 @@
+import fs from 'fs/promises';
+import path from 'path';
+export async function getDefaultProjectName(projectPath) {
+    try {
+        const packageJson = JSON.parse(await fs.readFile(path.join(projectPath, 'package.json'), 'utf-8'));
+        if (typeof packageJson.name === 'string' && packageJson.name.trim()) {
+            return packageJson.name.replace(/^@[^/]+\//, '');
+        }
+    } catch  {
+    // Fall back to directory name.
+    }
+    return path.basename(path.resolve(projectPath)) || 'figma-project';
+}

package/dist/commands/prompt-to-create-project/prompt-for-available-subdomain.d.ts

@@ -0,0 +1,7 @@
+import type { AuthCredential } from '../../auth/credentials.js';
+interface PromptForAvailableSubdomainArgs {
+    credential: AuthCredential;
+    initialValue: string;
+}
+export declare function promptForAvailableSubdomain({ credential, initialValue, }: PromptForAvailableSubdomainArgs): Promise<string>;
+export {};

package/dist/commands/prompt-to-create-project/prompt-for-available-subdomain.js

@@ -0,0 +1,32 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { checkProjectSubdomainAvailability } from '../../api/check-project-subdomain-availability.js';
+import { formatUnavailableSubdomainReason } from './format-unavailable-subdomain-reason.js';
+import { validateSubdomain } from './validate-subdomain.js';
+export async function promptForAvailableSubdomain({ credential, initialValue }) {
+    let nextInitialValue = initialValue;
+    while(true){
+        const promptedSubdomain = await p.text({
+            initialValue: nextInitialValue,
+            message: 'Project subdomain:',
+            validate: validateSubdomain
+        });
+        const subdomain = unwrapPrompt(promptedSubdomain).trim();
+        const availability = await checkProjectSubdomainAvailability({
+            credential,
+            subdomain
+        });
+        if (availability.available) {
+            return subdomain;
+        }
+        p.log.error(pc.red(formatUnavailableSubdomainReason(availability.reason)));
+        nextInitialValue = subdomain;
+    }
+}
+function unwrapPrompt(value) {
+    if (p.isCancel(value)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return value;
+}

package/dist/commands/prompt-to-create-project/resolve-project-region.d.ts

@@ -0,0 +1,8 @@
+import type { ProjectResourceType } from '../../api/project-resource-type.js';
+interface ResolveProjectRegionArgs {
+    nonInteractive?: boolean;
+    resourceType: ProjectResourceType;
+    value?: string;
+}
+export declare function resolveProjectRegion({ nonInteractive, resourceType, value, }: ResolveProjectRegionArgs): Promise<string>;
+export {};

package/dist/commands/prompt-to-create-project/resolve-project-region.js

@@ -0,0 +1,27 @@
+import * as p from '@clack/prompts';
+export async function resolveProjectRegion({ nonInteractive, resourceType, value }) {
+    if (value !== undefined) {
+        const region = value.trim();
+        if (!region) {
+            throw new Error('Region is required');
+        }
+        return region;
+    }
+    if (resourceType === 'vite' || nonInteractive) {
+        return 'us-east-1';
+    }
+    const selectedRegion = await p.select({
+        message: 'Select a region:',
+        options: [
+            {
+                label: 'US East (us-east-1)',
+                value: 'us-east-1'
+            }
+        ]
+    });
+    if (p.isCancel(selectedRegion)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return selectedRegion;
+}

package/dist/commands/prompt-to-create-project/resolve-project-subdomain.d.ts

@@ -0,0 +1,9 @@
+import type { AuthCredential } from '../../auth/credentials.js';
+interface ResolveProjectSubdomainArgs {
+    credential: AuthCredential;
+    initialValue: string;
+    nonInteractive?: boolean;
+    value?: string;
+}
+export declare function resolveProjectSubdomain({ credential, initialValue, nonInteractive, value, }: ResolveProjectSubdomainArgs): Promise<string>;
+export {};

package/dist/commands/prompt-to-create-project/resolve-project-subdomain.js

@@ -0,0 +1,54 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { checkProjectSubdomainAvailability } from '../../api/check-project-subdomain-availability.js';
+import { formatUnavailableSubdomainReason } from './format-unavailable-subdomain-reason.js';
+import { promptForAvailableSubdomain } from './prompt-for-available-subdomain.js';
+import { validateSubdomain } from './validate-subdomain.js';
+const GENERATED_SUBDOMAIN_ATTEMPT_COUNT = 5;
+export async function resolveProjectSubdomain({ credential, initialValue, nonInteractive, value }) {
+    const providedSubdomain = value === undefined ? undefined : validateProvidedSubdomain(value);
+    if (!nonInteractive) {
+        if (providedSubdomain) {
+            const availability = await checkProjectSubdomainAvailability({
+                credential,
+                subdomain: providedSubdomain
+            });
+            if (availability.available) {
+                return providedSubdomain;
+            }
+            p.log.error(pc.red(formatUnavailableSubdomainReason(availability.reason)));
+        }
+        return promptForAvailableSubdomain({
+            credential,
+            initialValue: providedSubdomain ?? initialValue
+        });
+    }
+    const baseSubdomain = providedSubdomain ?? initialValue;
+    for(let attempt = 0; attempt < GENERATED_SUBDOMAIN_ATTEMPT_COUNT; attempt++){
+        const subdomain = attempt === 0 ? baseSubdomain : addRandomSuffix(baseSubdomain);
+        const availability = await checkProjectSubdomainAvailability({
+            credential,
+            subdomain
+        });
+        if (availability.available) {
+            return subdomain;
+        }
+        if (providedSubdomain) {
+            throw new Error(`${formatUnavailableSubdomainReason(availability.reason)} Pass a different --subdomain.`);
+        }
+    }
+    throw new Error(`Could not generate an available subdomain after ${GENERATED_SUBDOMAIN_ATTEMPT_COUNT} attempts. Pass --subdomain.`);
+}
+function validateProvidedSubdomain(value) {
+    const validationError = validateSubdomain(value);
+    if (validationError) {
+        throw new Error(validationError);
+    }
+    return value.trim();
+}
+function addRandomSuffix(value) {
+    // Append a hyphen and six random lowercase alphanumeric characters, e.g. `-a1b2c3`.
+    const suffix = Math.random().toString(36).slice(2, 8).padEnd(6, '0');
+    const prefix = value.slice(0, 53).replace(/-+$/g, '');
+    return `${prefix}-${suffix}`;
+}

package/dist/commands/prompt-to-create-project/resolve-text-input.d.ts

@@ -0,0 +1,9 @@
+interface ResolveTextInputArgs {
+    fieldName: string;
+    initialValue: string;
+    message: string;
+    nonInteractive?: boolean;
+    value?: string;
+}
+export declare function resolveTextInput({ fieldName, initialValue, message, nonInteractive, value, }: ResolveTextInputArgs): Promise<string>;
+export {};

package/dist/commands/prompt-to-create-project/resolve-text-input.js

@@ -0,0 +1,23 @@
+import * as p from '@clack/prompts';
+export async function resolveTextInput({ fieldName, initialValue, message, nonInteractive, value }) {
+    if (value !== undefined) {
+        const trimmedValue = value.trim();
+        if (!trimmedValue) {
+            throw new Error(`${fieldName} is required`);
+        }
+        return trimmedValue;
+    }
+    if (nonInteractive) {
+        return initialValue;
+    }
+    const promptedValue = await p.text({
+        initialValue,
+        message,
+        validate: (candidate)=>candidate?.trim() ? undefined : `${fieldName} is required`
+    });
+    if (p.isCancel(promptedValue)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return promptedValue.trim();
+}

package/dist/commands/prompt-to-create-project/resolve-workspace-plan-key.d.ts

@@ -0,0 +1,12 @@
+interface ProjectWorkspace {
+    isDefault: boolean;
+    name: string;
+    planKey: string;
+}
+interface ResolveWorkspacePlanKeyArgs {
+    nonInteractive?: boolean;
+    value?: string;
+    workspaces: ProjectWorkspace[];
+}
+export declare function resolveWorkspacePlanKey({ nonInteractive, value, workspaces, }: ResolveWorkspacePlanKeyArgs): Promise<string>;
+export {};

package/dist/commands/prompt-to-create-project/resolve-workspace-plan-key.js

@@ -0,0 +1,36 @@
+import * as p from '@clack/prompts';
+export async function resolveWorkspacePlanKey({ nonInteractive, value, workspaces }) {
+    if (value !== undefined) {
+        const planKey = value.trim();
+        const workspace = workspaces.find((candidate)=>candidate.planKey === planKey);
+        if (!workspace) {
+            throw new Error(`Workspace plan key "${planKey}" is not eligible. Available: ${formatWorkspaces(workspaces)}`);
+        }
+        return workspace.planKey;
+    }
+    if (workspaces.length === 1) {
+        return workspaces[0].planKey;
+    }
+    if (nonInteractive) {
+        const defaultWorkspace = workspaces.find((workspace)=>workspace.isDefault);
+        if (defaultWorkspace) {
+            return defaultWorkspace.planKey;
+        }
+        throw new Error(`Multiple eligible Figma workspaces. Pass --workspace <plan-key>. Available: ${formatWorkspaces(workspaces)}`);
+    }
+    const selectedWorkspacePlanKey = await p.select({
+        message: 'Select a Figma workspace:',
+        options: workspaces.map((workspace)=>({
+                label: workspace.name,
+                value: workspace.planKey
+            }))
+    });
+    if (p.isCancel(selectedWorkspacePlanKey)) {
+        p.cancel('Operation cancelled');
+        process.exit(0);
+    }
+    return selectedWorkspacePlanKey;
+}
+function formatWorkspaces(workspaces) {
+    return workspaces.map((workspace)=>`${workspace.name} (${workspace.planKey})`).join(', ');
+}

package/dist/commands/prompt-to-create-project/validate-subdomain.d.ts

@@ -0,0 +1 @@
+export declare function validateSubdomain(value: string | undefined): "Subdomain is required" | "Use 1–60 lowercase letters, numbers, or hyphens" | undefined;

package/dist/commands/prompt-to-create-project/validate-subdomain.js

@@ -0,0 +1,9 @@
+export function validateSubdomain(value) {
+    if (!value?.trim()) {
+        return 'Subdomain is required';
+    }
+    if (!/^[a-z0-9](?:[a-z0-9-]{0,58}[a-z0-9])?$/.test(value.trim())) {
+        return 'Use 1–60 lowercase letters, numbers, or hyphens';
+    }
+    return undefined;
+}

package/dist/commands/prompt-to-create-project.d.ts

@@ -0,0 +1,24 @@
+import type { ProjectResourceType } from '../api/project-resource-type.js';
+import type { AuthCredential } from '../auth/credentials.js';
+interface ProjectCreationInputs {
+    description?: string;
+    name?: string;
+    region?: string;
+    subdomain?: string;
+    workspacePlanKey?: string;
+}
+interface PromptToCreateProjectArgs {
+    credential: AuthCredential;
+    inputs?: ProjectCreationInputs;
+    nonInteractive?: boolean;
+    projectPath: string;
+    resourceType: ProjectResourceType;
+}
+interface PromptToCreateProjectResponse {
+    domainName: string;
+    id: string;
+    name: string;
+}
+/** Prompt for required project fields and create a blank Figma CMS project. */
+export declare function promptToCreateProject({ credential, inputs, nonInteractive, projectPath, resourceType, }: PromptToCreateProjectArgs): Promise<PromptToCreateProjectResponse>;
+export {};

package/dist/commands/prompt-to-create-project.js

@@ -0,0 +1,69 @@
+import * as p from '@clack/prompts';
+import pc from 'picocolors';
+import { createProject } from '../api/create-project.js';
+import { listProjectWorkspaces } from '../api/list-project-workspaces.js';
+import { formatProjectSubdomain } from './prompt-to-create-project/format-project-subdomain.js';
+import { getDefaultProjectName } from './prompt-to-create-project/get-default-project-name.js';
+import { resolveProjectRegion } from './prompt-to-create-project/resolve-project-region.js';
+import { resolveProjectSubdomain } from './prompt-to-create-project/resolve-project-subdomain.js';
+import { resolveTextInput } from './prompt-to-create-project/resolve-text-input.js';
+import { resolveWorkspacePlanKey } from './prompt-to-create-project/resolve-workspace-plan-key.js';
+/** Prompt for required project fields and create a blank Figma CMS project. */ export async function promptToCreateProject({ credential, inputs, nonInteractive, projectPath, resourceType }) {
+    const workspaces = await listProjectWorkspaces(credential);
+    if (workspaces.length === 0) {
+        if (nonInteractive) {
+            throw new Error('No eligible Figma workspaces found.');
+        }
+        p.log.error(pc.red('No eligible Figma workspaces found.'));
+        process.exit(1);
+    }
+    const defaultProjectName = await getDefaultProjectName(projectPath);
+    const projectName = await resolveTextInput({
+        fieldName: 'Project name',
+        initialValue: defaultProjectName,
+        message: 'Project name:',
+        nonInteractive,
+        value: inputs?.name
+    });
+    const projectDescription = await resolveTextInput({
+        fieldName: 'Description',
+        initialValue: `${projectName} project`,
+        message: 'Project description:',
+        nonInteractive,
+        value: inputs?.description
+    });
+    const projectSubdomain = await resolveProjectSubdomain({
+        credential,
+        initialValue: formatProjectSubdomain(projectName),
+        nonInteractive,
+        value: inputs?.subdomain
+    });
+    const parentPlanKey = await resolveWorkspacePlanKey({
+        nonInteractive,
+        value: inputs?.workspacePlanKey,
+        workspaces
+    });
+    const region = await resolveProjectRegion({
+        nonInteractive,
+        resourceType,
+        value: inputs?.region
+    });
+    const spinner = p.spinner();
+    spinner.start('Creating Figma project...');
+    try {
+        const project = await createProject({
+            name: projectName,
+            credential,
+            description: projectDescription,
+            parentPlanKey,
+            region,
+            resourceType,
+            subdomain: projectSubdomain
+        });
+        spinner.stop(pc.green(`✓ Project created: ${project.domainName}`));
+        return project;
+    } catch (error) {
+        spinner.stop(pc.red('✗ Failed to create project'));
+        throw error;
+    }
+}

package/dist/commands/setup-agent.d.ts

@@ -0,0 +1,12 @@
+export interface SetupAgentOptions {
+    global?: boolean;
+    project?: boolean;
+    yes?: boolean;
+}
+/** Install or update the bundled deploy skill through the standard skills CLI. */
+export declare function setupAgentCommand(options: SetupAgentOptions, dependencies?: {
+    homeDir?: string;
+    isTTY?: boolean;
+    projectDir?: string;
+    skillDir?: string;
+}): Promise<void>;

package/dist/commands/setup-agent.js

@@ -0,0 +1,123 @@
+import * as p from '@clack/prompts';
+import spawn from 'cross-spawn';
+import crypto from 'node:crypto';
+import fs from 'node:fs/promises';
+import { createRequire } from 'node:module';
+import os from 'node:os';
+import path from 'node:path';
+const SKILL_NAME = 'deploy-to-figma';
+const require = createRequire(import.meta.url);
+const SKILLS_CLI_PATH = require.resolve('skills/bin/cli.mjs');
+/** Install or update the bundled deploy skill through the standard skills CLI. */ export async function setupAgentCommand(options, dependencies = {}) {
+    if (options.global && options.project) {
+        throw new Error('Use either --global or --project, not both.');
+    }
+    const isTTY = dependencies.isTTY ?? Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    const scope = await resolveScope(options, isTTY);
+    const projectDir = dependencies.projectDir ?? process.cwd();
+    const homeDir = dependencies.homeDir ?? os.homedir();
+    const skillDir = dependencies.skillDir ?? resolveBundledSkillDir();
+    const installedDir = path.join(scope === 'global' ? homeDir : projectDir, '.agents', 'skills', SKILL_NAME);
+    const [bundledHash, installedHash] = await Promise.all([
+        hashDirectory(skillDir),
+        hashDirectory(installedDir)
+    ]);
+    if (!bundledHash) {
+        throw new Error(`Bundled ${SKILL_NAME} skill was not found at ${skillDir}.`);
+    }
+    if (bundledHash === installedHash) {
+        p.log.success(`✓ ${SKILL_NAME} skill is already up to date (${scope})`);
+        return;
+    }
+    p.log.step(`${installedHash ? 'Updating' : 'Installing'} ${SKILL_NAME} skill (${scope})...`);
+    const args = [
+        'add',
+        skillDir,
+        '--skill',
+        SKILL_NAME,
+        '--copy',
+        ...scope === 'global' ? [
+            '--global'
+        ] : [],
+        ...options.yes || !isTTY ? [
+            '--yes'
+        ] : []
+    ];
+    const exitCode = await run(process.execPath, [
+        SKILLS_CLI_PATH,
+        ...args
+    ], projectDir);
+    if (exitCode !== 0) {
+        throw new Error(`Skill installation failed with exit code ${exitCode}.`);
+    }
+    p.log.success(`✓ ${SKILL_NAME} skill ${installedHash ? 'updated' : 'installed'} (${scope})`);
+}
+async function resolveScope(options, isTTY) {
+    if (options.global) {
+        return 'global';
+    }
+    if (options.project) {
+        return 'project';
+    }
+    if (!isTTY) {
+        throw new Error('Non-interactive setup requires either --global or --project.');
+    }
+    const selected = await p.select({
+        initialValue: 'global',
+        message: 'Where should the Figma deploy skill be installed?',
+        options: [
+            {
+                label: 'Globally (recommended)',
+                value: 'global'
+            },
+            {
+                label: 'Current project only',
+                value: 'project'
+            }
+        ]
+    });
+    if (p.isCancel(selected)) {
+        throw new Error('Skill installation cancelled.');
+    }
+    return selected;
+}
+function resolveBundledSkillDir() {
+    return path.resolve(import.meta.dirname, '..', 'skills', SKILL_NAME);
+}
+async function hashDirectory(directory) {
+    if (!await pathExists(directory)) {
+        return null;
+    }
+    const hash = crypto.createHash('sha256');
+    async function visit(currentDir, relativeDir = '') {
+        const entries = await fs.readdir(currentDir, {
+            withFileTypes: true
+        });
+        entries.sort((left, right)=>left.name.localeCompare(right.name));
+        for (const entry of entries){
+            const relativePath = path.join(relativeDir, entry.name);
+            const absolutePath = path.join(currentDir, entry.name);
+            if (entry.isDirectory()) {
+                await visit(absolutePath, relativePath);
+            } else if (entry.isFile()) {
+                hash.update(relativePath);
+                hash.update(await fs.readFile(absolutePath));
+            }
+        }
+    }
+    await visit(directory);
+    return hash.digest('hex');
+}
+function run(command, args, cwd) {
+    return new Promise((resolve, reject)=>{
+        const child = spawn(command, args, {
+            cwd,
+            stdio: 'inherit'
+        });
+        child.once('error', reject);
+        child.once('close', (code)=>resolve(code ?? 1));
+    });
+}
+async function pathExists(filePath) {
+    return fs.access(filePath).then(()=>true).catch(()=>false);
+}

package/dist/commands/write-project-configuration.d.ts

@@ -0,0 +1,12 @@
+import type { BootstrapInfo } from '../api/control-plane.js';
+import type { TokenStore } from '../auth/token-store.js';
+interface WriteProjectConfigurationArgs {
+    bootstrapInfo: BootstrapInfo | null;
+    environmentName: string;
+    projectDir: string;
+    projectId: string;
+    shouldWriteEnvironmentVariables?: boolean;
+    tokenStore: TokenStore;
+}
+export declare function writeProjectConfiguration({ bootstrapInfo, environmentName, projectDir, projectId, shouldWriteEnvironmentVariables, tokenStore, }: WriteProjectConfigurationArgs): Promise<void>;
+export {};

package/dist/commands/write-project-configuration.js

@@ -0,0 +1,16 @@
+import { getInfraEnvironment } from '../constants.js';
+import { cacheAllEnvironments } from '../utils/cache-bootstrap.js';
+import { addOrUpdateEnvVar } from '../utils/env-management.js';
+export async function writeProjectConfiguration({ bootstrapInfo, environmentName, projectDir, projectId, shouldWriteEnvironmentVariables = true, tokenStore }) {
+    if (shouldWriteEnvironmentVariables) {
+        await addOrUpdateEnvVar(projectDir, 'FIGMA_PROJECT_ID', projectId);
+        await addOrUpdateEnvVar(projectDir, 'FIGMA_ENVIRONMENT_NAME', environmentName);
+        const infraEnvironment = getInfraEnvironment();
+        if (infraEnvironment !== 'production') {
+            await addOrUpdateEnvVar(projectDir, 'FIGMA_INFRA_ENV', infraEnvironment);
+        }
+    }
+    if (bootstrapInfo) {
+        cacheAllEnvironments(tokenStore, projectId, bootstrapInfo);
+    }
+}

package/dist/db-content-api/index.js

@@ -9,6 +9,7 @@ import { unwrapDocument, unwrapFindResponse } from './temp-utilities/unwrapDocum
 import { createAuthMiddleware, createErrorMiddleware } from './utilities/auth.js';
 import { getClientVersionHeaders } from './utilities/clientVersionHeaders.js';
 import { dataToContentAPI, resolveVersionContent } from './utilities/data/index.js';
+import { injectGlobalType } from './utilities/data/injectGlobalType.js';
 import { validateRelationshipIds } from './utilities/data/validateRelationships.js';
 import { convertPayloadJoinsToContentAPI } from './utilities/joins.js';
 import { addFallbackLocale } from './utilities/locale/index.js';
@@ -301,9 +302,12 @@ async function updateVersion(args) {
     });
 }
 async function deleteVersions(args) {
-    const collection = args.collection;
+    // Globals are addressed by `globalSlug` and map to the `_global-<slug>` collection.
+    // Only one of `collection`/`globalSlug` is set.
+    const globalSlug = args.globalSlug != null ? getGlobalSlug(args.globalSlug) : undefined;
+    const collection = args.collection ?? globalSlug;
     if (collection == null) {
-        throw new Error('deleteVersions requires a collection');
+        throw new Error('deleteVersions requires a collection or globalSlug');
     }
     const locale = addFallbackLocale(args.locale, this.payload);
     const { error, response: httpResponse } = await this.client.POST('/api/v1/document_versions:delete', {
@@ -621,16 +625,22 @@ async function upsert(args) {
         data: args.data,
         payload: this.payload
     });
+    // `createdAt` is create-time metadata, so seed it on `createOnMissing` (used only when no
+    // document matches) rather than on `doc`. The server preserves an existing document's
+    // `createdAt` on update precisely because `doc` omits it; `updatedAt` is still refreshed on
+    // every write via `dataToContentAPI`. Sending `createdAt` on `doc` would overwrite it on
+    // every update (e.g. repeated `updateGlobal` calls).
+    const createdAt = new Date().toISOString();
     const { data: contentAPIResponse, error, response: httpResponse } = await this.client.POST('/api/v1/documents:update', {
         body: {
             collection: args.collection,
             contentSystemId: this.contentSystemId,
             createOnMissing: {
-                id: documentId
+                id: documentId,
+                createdAt
             },
             doc: dataToContentAPI(this.payload, args.collection, args.data, {
-                applyDefaults: true,
-                createdAt: true
+                applyDefaults: true
             }),
             environmentName: this.environmentName,
             locale,
@@ -716,13 +726,13 @@ async function updateJobs(args) {
             payload: this.payload
         }));
 }
-function createGlobal(args) {
+async function createGlobal(args) {
     // Globals are singletons identified by their slug. Use upsert so concurrent calls
     // (e.g. handleSchedules processing multiple queueables with the same null jobStats)
     // don't fail with "A record with this field already exists". The deep-merge semantics
     // of the update path are safe here: callers that want a fresh create (first run) get
     // an effective create, and callers that race a prior create get a merge instead.
-    return this.upsert({
+    const doc = await this.upsert({
         collection: getGlobalSlug(args.slug),
         data: {
             ...args.data,
@@ -734,6 +744,7 @@ function createGlobal(args) {
             }
         }
     });
+    return injectGlobalType(doc, args.slug);
 }
 async function findGlobal(args) {
     const doc = await this.findOne({
@@ -741,17 +752,10 @@ async function findGlobal(args) {
         locale: args.locale,
         where: args.where ?? {}
     });
-    if (doc != null) {
-        ;
-        doc.globalType = args.slug;
-    }
-    return doc;
+    return injectGlobalType(doc, args.slug);
 }
 async function updateGlobal(args) {
-    // TODO: upsert's `createOnMissing` path generates a new `createdAt` on every call,
-    // which overwrites the original timestamp on updates. The fix belongs in the Content API:
-    // `createOnMissing` should preserve `createdAt` on updates and only set it on creates.
-    return this.upsert({
+    const doc = await this.upsert({
         collection: getGlobalSlug(args.slug),
         data: args.data,
         where: {
@@ -760,6 +764,7 @@ async function updateGlobal(args) {
             }
         }
     });
+    return injectGlobalType(doc, args.slug);
 }
 // TODO: remove Omit when this PR is released: https://github.com/payloadcms/payload/pull/15183
 function findGlobalVersions(args) {

package/dist/db-content-api/utilities/data/injectGlobalType.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Payload expects globals to carry a `globalType` (their slug) alongside the stored data.
+ * Globals are stored as `_global-<slug>` collections that have no such column, so the adapter
+ * attaches it to every global document it returns.
+ */
+export declare function injectGlobalType<T>(doc: T, slug: string): T;

package/dist/db-content-api/utilities/data/injectGlobalType.js

@@ -0,0 +1,11 @@
+import { isRecord } from '../isRecord.js';
+/**
+ * Payload expects globals to carry a `globalType` (their slug) alongside the stored data.
+ * Globals are stored as `_global-<slug>` collections that have no such column, so the adapter
+ * attaches it to every global document it returns.
+ */ export function injectGlobalType(doc, slug) {
+    return isRecord(doc) ? {
+        ...doc,
+        globalType: slug
+    } : doc;
+}

package/dist/db-content-api/utilities/data/stringifyNumericIds.d.ts

@@ -0,0 +1 @@
+export declare function stringifyNumericIds(value: unknown): unknown;