Add intents registration for admin_link

Author: vividviolet

packages/app/src/cli/models/extensions/specification.ts

@@ -1,5 +1,6 @@
 import {ZodSchemaType, BaseConfigType, BaseSchema} from './schemas.js'
 import {ExtensionInstance} from './extension-instance.js'
+import {adminLinkOverride} from './specifications/remote-overrides/admin_link.js'
 import {blocks} from '../../constants.js'
 import {ClientSteps} from '../../services/build/client-steps.js'
 
@@ -58,7 +59,7 @@ export interface BuildAsset {
 }
 
 type BuildConfig =
-  | {mode: 'ui' | 'theme' | 'function' | 'tax_calculation' | 'none' | 'hosted_app_home'}
+  | {mode: 'ui' | 'theme' | 'function' | 'tax_calculation' | 'none' | 'hosted_app_home' | 'copy_static_assets'}
   | {mode: 'copy_files'; filePatterns: string[]; ignoredFilePatterns?: string[]}
 
 /**
@@ -173,6 +174,11 @@ interface CreateExtensionSpecType<TConfiguration extends BaseConfigType = BaseCo
   schema?: ZodSchemaType<TConfiguration>
 }
 
+export type CreateContractOverrideExtensionSpecType<TConfiguration extends BaseConfigType = BaseConfigType> = Partial<
+  CreateExtensionSpecType<TConfiguration>
+> & {
+  transform?: (config: TConfiguration) => TConfiguration
+}
 /**
  * Create a new ui extension spec.
  *
@@ -286,34 +292,31 @@ export function createConfigExtensionSpecification<TConfiguration extends BaseCo
 }
 
 export function createContractBasedModuleSpecification<TConfiguration extends BaseConfigType = BaseConfigType>(
-  spec: Pick<
-    CreateExtensionSpecType<TConfiguration>,
-    | 'identifier'
-    | 'appModuleFeatures'
-    | 'buildConfig'
-    | 'uidStrategy'
-    | 'clientSteps'
-    | 'experience'
-    | 'transformRemoteToLocal'
-  >,
+  spec: Pick<CreateExtensionSpecType<TConfiguration>, 'identifier' | 'appModuleFeatures'> &
+    CreateContractOverrideExtensionSpecType<TConfiguration>,
 ) {
+  const defaultDeployConfig = async (config: TConfiguration, directory: string) => {
+    let parsedConfig = configWithoutFirstClassFields(config)
+    if (spec.appModuleFeatures().includes('localization')) {
+      const localization = await loadLocalesConfig(directory, spec.identifier)
+      parsedConfig = {...parsedConfig, localization}
+    }
+    return parsedConfig
+  }
+
+  const schema = spec.transform ? zod.any({}).transform(spec.transform) : zod.any({})
+
   return createExtensionSpecification({
+    ...spec,
+    schema,
     identifier: spec.identifier,
-    schema: zod.any({}) as unknown as ZodSchemaType<TConfiguration>,
     appModuleFeatures: spec.appModuleFeatures,
     experience: spec.experience,
     buildConfig: spec.buildConfig ?? {mode: 'none'},
     clientSteps: spec.clientSteps,
     uidStrategy: spec.uidStrategy,
     transformRemoteToLocal: spec.transformRemoteToLocal,
-    deployConfig: async (config, directory) => {
-      let parsedConfig = configWithoutFirstClassFields(config)
-      if (spec.appModuleFeatures().includes('localization')) {
-        const localization = await loadLocalesConfig(directory, spec.identifier)
-        parsedConfig = {...parsedConfig, localization}
-      }
-      return parsedConfig
-    },
+    deployConfig: spec.deployConfig ?? defaultDeployConfig,
   })
 }
 
@@ -431,3 +434,37 @@ export function configWithoutFirstClassFields(config: JsonMapType): JsonMapType
   const {type, handle, uid, path, extensions, ...configWithoutFirstClassFields} = config
   return configWithoutFirstClassFields
 }
+
+/**
+ * Specification overrides for remote specifications that need custom behavior.
+ * These overrides are applied when creating contract-based module specifications
+ * for extensions that are defined remotely but need local customization.
+ *
+ * Can include any method from ExtensionSpecification plus a schema.
+ * All properties are optional - only provide what you want to override.
+ */
+export type SpecificationOverride<TConfiguration extends BaseConfigType = BaseConfigType> = Partial<
+  ExtensionSpecification<TConfiguration>
+> & {
+  schema?: ZodSchemaType<TConfiguration>
+}
+
+/**
+ * Registry of specification overrides by identifier.
+ * Add custom behavior for remote specifications here.
+ */
+export const SPECIFICATION_OVERRIDES: {[key: string]: SpecificationOverride} = {
+  admin_link: adminLinkOverride as unknown as SpecificationOverride,
+}
+
+/**
+ * Get the override configuration for a specific specification identifier.
+ *
+ * @param identifier - The specification identifier
+ * @returns The override configuration if it exists, undefined otherwise
+ */
+export function getSpecificationOverride<TConfiguration extends BaseConfigType = BaseConfigType>(
+  identifier: string,
+): SpecificationOverride<TConfiguration> | undefined {
+  return SPECIFICATION_OVERRIDES[identifier] as SpecificationOverride<TConfiguration> | undefined
+}

packages/app/src/cli/models/extensions/specifications/build-manifest-schema.ts

@@ -1,5 +1,5 @@
 import {AssetIdentifier, BuildAsset} from '../specification.js'
-import {fileExists, copyFile} from '@shopify/cli-kit/node/fs'
+import {fileExists, copyFile, mkdir} from '@shopify/cli-kit/node/fs'
 import {joinPath, dirname, basename} from '@shopify/cli-kit/node/path'
 import {outputContent, outputToken} from '@shopify/cli-kit/node/output'
 import {err, ok, Result} from '@shopify/cli-kit/node/result'
@@ -14,7 +14,7 @@ export {ok, err}
  */
 export interface TargetingWithBuildManifest {
   target: string
-  build_manifest?: BuildManifest
+  build_manifest: BuildManifest
 }
 
 /**
@@ -142,6 +142,10 @@ async function copyAsset(
   if (isStatic) {
     const sourceFile = joinPath(directory, module)
     const outputFilePath = joinPath(dirname(outputPath), filepath)
+
+    // Ensure the directory exists before copying
+    await mkdir(dirname(outputFilePath))
+
     await copyFile(sourceFile, outputFilePath).catch((error) => {
       throw new Error(`Failed to copy static asset ${module} to ${outputFilePath}: ${error.message}`)
     })
@@ -217,9 +221,7 @@ export async function validateBuildManifestAssets(
  * @param extensionPoint - Extension point with build manifest
  * @returns Extension point with updated asset paths
  */
-export function addDistPathToAssets<T extends TargetingWithBuildManifest & {build_manifest: BuildManifest}>(
-  extP: T,
-): T {
+export function addDistPathToAssets<T extends TargetingWithBuildManifest>(extP: T): T {
   return {
     ...extP,
     build_manifest: {

packages/app/src/cli/models/extensions/specifications/remote-overrides/admin_link.ts

@@ -0,0 +1,46 @@
+import {
+  transformStaticAssets,
+  copyStaticBuildManifestAssets,
+  validateBuildManifestAssets,
+  addDistPathToAssets,
+  TargetingWithBuildManifest,
+} from '../build-manifest-schema.js'
+import {configWithoutFirstClassFields, CreateContractOverrideExtensionSpecType} from '../../specification.js'
+import {ExtensionInstance} from '../../extension-instance.js'
+import {loadLocalesConfig} from '../../../../utilities/extensions/locales-configuration.js'
+import {JsonMapType} from '@shopify/cli-kit/node/toml'
+
+interface AdminLinkPartialConfig {
+  targeting: TargetingWithBuildManifest[]
+  handle?: string
+}
+
+export const adminLinkOverride: CreateContractOverrideExtensionSpecType<AdminLinkPartialConfig> = {
+  getOutputRelativePath: (extension: ExtensionInstance<AdminLinkPartialConfig>) => `dist/${extension.handle}.js`,
+  buildConfig: {mode: 'copy_static_assets'},
+  transform: (config: AdminLinkPartialConfig) => {
+    return {
+      ...config,
+      targeting: config.targeting.map((targeting) => {
+        return {
+          ...targeting,
+          ...transformStaticAssets(targeting, config.handle ?? 'admin-link'),
+        }
+      }),
+    }
+  },
+  validate: async (config: AdminLinkPartialConfig, _path: string, directory: string) =>
+    validateBuildManifestAssets(directory, config.targeting),
+  copyStaticAssets: async (config: AdminLinkPartialConfig, directory: string, outputPath: string) =>
+    copyStaticBuildManifestAssets(config.targeting, directory, outputPath),
+  deployConfig: async (config: AdminLinkPartialConfig, directory: string) => {
+    const parsedConfig = configWithoutFirstClassFields(config as unknown as JsonMapType)
+    const localization = await loadLocalesConfig(directory, 'admin_link')
+
+    return {
+      ...parsedConfig,
+      localization,
+      targeting: config.targeting.map(addDistPathToAssets),
+    }
+  },
+}

packages/app/src/cli/models/extensions/specifications/ui_extension.ts

@@ -12,6 +12,7 @@ import {
   addDistPathToAssets,
   transformStaticAssets,
   BuildManifest,
+  TargetingWithBuildManifest,
 } from './build-manifest-schema.js'
 import {Asset, AssetIdentifier, ExtensionFeature, createExtensionSpecification} from '../specification.js'
 import {NewExtensionPointSchemaType, NewExtensionPointsSchema, BaseSchema, MetafieldSchema} from '../schemas.js'
@@ -33,6 +34,9 @@ const validatePoints = (config: {extension_points?: unknown[]; targeting?: unkno
 
 const missingExtensionPointsMessage = 'No extension targets defined, add a `targeting` field to your configuration'
 
+// Re-export BuildManifest for backward compatibility with files that import it from ui_extension
+export type {BuildManifest}
+
 type UIExtensionConfigType = zod.infer<typeof UIExtensionSchema>
 export const UIExtensionSchema = BaseSchema.extend({
   name: zod.string(),
@@ -312,7 +316,7 @@ const uiExtensionSpec = createExtensionSpecification({
 
 async function validateUIExtensionPointConfig(
   directory: string,
-  extensionPoints: (NewExtensionPointSchemaType & {build_manifest?: BuildManifest})[],
+  extensionPoints: (NewExtensionPointSchemaType & TargetingWithBuildManifest)[],
   configPath: string,
 ): Promise<Result<unknown, string>> {
   const errors: string[] = []

packages/app/src/cli/services/dev/extension/payload/store.test.ts

@@ -212,6 +212,53 @@ describe('ExtensionsPayloadStore()', () => {
       })
     })
 
+    test('replaces arrays in extension points instead of merging them', () => {
+      // Given — initial payload has intents with resolved schema (Asset objects)
+      const payload = {
+        extensions: [
+          {
+            uuid: '123',
+            extensionPoints: [
+              {
+                target: 'admin.app.intent.link',
+                resource: {url: ''},
+                intents: [
+                  {
+                    type: 'application/email',
+                    action: 'edit',
+                    schema: {name: 'schema', url: '/old-url', lastUpdated: 1},
+                  },
+                ],
+              },
+            ],
+          },
+        ],
+      } as unknown as ExtensionsEndpointPayload
+
+      const extensionsPayloadStore = new ExtensionsPayloadStore(payload, mockOptions)
+
+      // When — update with new intents (simulating a rebuild)
+      extensionsPayloadStore.updateExtensions([
+        {
+          uuid: '123',
+          extensionPoints: [
+            {
+              target: 'admin.app.intent.link',
+              resource: {url: ''},
+              intents: [
+                {type: 'application/email', action: 'edit', schema: {name: 'schema', url: '/new-url', lastUpdated: 2}},
+              ],
+            },
+          ],
+        },
+      ] as unknown as UIExtensionPayload[])
+
+      // Then — intents should be replaced, not accumulated
+      const extensionPoints = extensionsPayloadStore.getRawPayload().extensions[0]?.extensionPoints as any[]
+      expect(extensionPoints[0].intents).toHaveLength(1)
+      expect(extensionPoints[0].intents[0].schema.url).toBe('/new-url')
+    })
+
     test('informs event listeners of updated extensions', () => {
       // Given
       const payload = {

packages/app/src/cli/services/dev/extension/payload/store.ts

@@ -104,7 +104,7 @@ export class ExtensionsPayloadStore extends EventEmitter {
               return (destinationArray as DevNewExtensionPointSchema[]).map((extensionPoint) => {
                 const extensionPointPayload = foundExtensionPointsPayloadMap[extensionPoint.target]
                 if (extensionPointPayload) {
-                  return deepMergeObjects(extensionPoint, extensionPointPayload)
+                  return deepMergeObjects(extensionPoint, extensionPointPayload, (_dest, source) => source)
                 }
                 return extensionPoint
               })