From d42b410050645dcac54a3bbefa6f20e219b7a807 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Tue, 18 Jun 2024 11:53:20 +0200
Subject: [PATCH 01/14] chore: initial pass at implementation from mob with
 simple test

Signed-off-by: blam <ben@blam.sh>
---
 .../src/wiring/createExtensionKind.test.tsx   |  44 +++++
 .../src/wiring/createExtensionKind.ts         | 164 ++++++++++++++++++
 2 files changed, 208 insertions(+)
 create mode 100644 packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
 create mode 100644 packages/frontend-plugin-api/src/wiring/createExtensionKind.ts

diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
new file mode 100644
index 0000000000..d841ea2c62
--- /dev/null
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
@@ -0,0 +1,44 @@
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import React from 'react';
+import { coreExtensionData } from './coreExtensionData';
+import { createExtensionKind } from './createExtensionKind';
+
+describe('createExtensionKind', () => {
+  it('should allow creation of extension kinds', () => {
+    const TestExtension = createExtensionKind({
+      kind: 'test-extension',
+      attachTo: { id: 'test', input: 'default' },
+      output: {
+        element: coreExtensionData.reactElement,
+      },
+      factory(_, props: { text: string }) {
+        return {
+          element: <h1>{props.text}</h1>,
+        };
+      },
+    });
+
+    const extension = TestExtension.new({
+      name: 'my-extension',
+      props: {
+        text: 'Hello, world!',
+      },
+    });
+
+    expect(extension).toBeDefined();
+  });
+});
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
new file mode 100644
index 0000000000..31a8e5da64
--- /dev/null
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -0,0 +1,164 @@
+import { AppNode } from '../apis';
+import { PortableSchema } from '../schema';
+import { Expand } from '../types';
+import {
+  AnyExtensionDataMap,
+  AnyExtensionInputMap,
+  ExtensionDataValues,
+  ResolvedExtensionInputs,
+  createExtension,
+} from './createExtension';
+
+/*
+ * Copyright 2024 The Backstage Authors
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+interface ExtensionKindOptions<
+  TProps,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  kind: string;
+  namespace?: string;
+  name?: string;
+  attachTo: { id: string; input: string };
+  disabled?: boolean;
+  inputs?: TInputs;
+  output: TOutput;
+  configSchema?: PortableSchema<TConfig>;
+  factory(
+    options: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    },
+    props: TProps,
+  ): Expand<ExtensionDataValues<TOutput>>;
+}
+
+class ExtensionKind<
+  TProps,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  static create<
+    TProps,
+    TInputs extends AnyExtensionInputMap,
+    TOutput extends AnyExtensionDataMap,
+    TConfig,
+  >(
+    options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>,
+  ): ExtensionKind<TProps, TInputs, TOutput, TConfig> {
+    return new ExtensionKind(options);
+  }
+
+  private constructor(
+    private readonly options: ExtensionKindOptions<
+      TProps,
+      TInputs,
+      TOutput,
+      TConfig
+    >,
+  ) {}
+
+  public new(options: {
+    namespace?: string;
+    name?: string;
+    attachTo?: { id: string; input: string };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output?: TOutput;
+    configSchema?: PortableSchema<TConfig>;
+    props: TProps;
+    factory?(
+      options: {
+        node: AppNode;
+        config: TConfig;
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        orignalFactory(
+          options?: {
+            node?: AppNode;
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+          },
+          props?: TProps,
+        ): Expand<ExtensionDataValues<TOutput>>;
+      },
+      props: TProps,
+    ): Expand<ExtensionDataValues<TOutput>>;
+  }) {
+    return createExtension({
+      kind: this.options.kind,
+      namespace: options.namespace ?? this.options.namespace,
+      name: options.name ?? this.options.name,
+      attachTo: options.attachTo ?? this.options.attachTo,
+      disabled: options.disabled ?? this.options.disabled,
+      inputs: options.inputs ?? this.options.inputs,
+      output: options.output ?? this.options.output,
+      configSchema: options.configSchema ?? this.options.configSchema, // TODO: some config merging or smth
+      factory: ({ node, config, inputs }) => {
+        if (options.factory) {
+          return options.factory(
+            {
+              node,
+              config,
+              inputs,
+              orignalFactory: (
+                innerOptions?: {
+                  node?: AppNode;
+                  config?: TConfig;
+                  inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+                },
+                innerProps?: TProps,
+              ) =>
+                this.options.factory(
+                  {
+                    node: innerOptions?.node ?? node,
+                    config: innerOptions?.config ?? config,
+                    inputs: innerOptions?.inputs ?? inputs,
+                  },
+                  innerProps ?? options.props,
+                ),
+            },
+            options.props,
+          );
+        }
+
+        return this.options.factory(
+          {
+            node,
+            config,
+            inputs,
+          },
+          options.props,
+        );
+      },
+    });
+  }
+}
+
+/**
+ * A simpler replacement for wrapping up `createExtension` inside a kind or type. This allows for a cleaner API for creating
+ * types and instances of those types.
+ */
+export function createExtensionKind<
+  TProps,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+>(options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>) {
+  return ExtensionKind.create(options);
+}

From d6c9f12ab3bc54f077e1d2baac8396c61c1c9cbf Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Tue, 18 Jun 2024 13:27:31 +0200
Subject: [PATCH 02/14] chore: add some simple tests

Signed-off-by: blam <ben@blam.sh>
---
 .../src/wiring/createExtensionKind.test.tsx   | 36 +++++++++++++++++++
 1 file changed, 36 insertions(+)

diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
index d841ea2c62..ea9459f3f6 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
@@ -16,6 +16,7 @@
 import React from 'react';
 import { coreExtensionData } from './coreExtensionData';
 import { createExtensionKind } from './createExtensionKind';
+import { createExtensionTester } from '@backstage/frontend-test-utils';
 
 describe('createExtensionKind', () => {
   it('should allow creation of extension kinds', () => {
@@ -40,5 +41,40 @@ describe('createExtensionKind', () => {
     });
 
     expect(extension).toBeDefined();
+
+    const { container } = createExtensionTester(extension).render();
+    expect(container.querySelector('h1')).toHaveTextContent('Hello, world!');
+  });
+
+  it('should allow overriding of the default factory', () => {
+    const TestExtension = createExtensionKind({
+      kind: 'test-extension',
+      attachTo: { id: 'test', input: 'default' },
+      output: {
+        element: coreExtensionData.reactElement,
+      },
+      factory(_, props: { text: string }) {
+        return {
+          element: <h1>{props.text}</h1>,
+        };
+      },
+    });
+
+    const extension = TestExtension.new({
+      name: 'my-extension',
+      props: {
+        text: 'Hello, world!',
+      },
+      factory(_, props: { text: string }) {
+        return {
+          element: <h2>{props.text}</h2>,
+        };
+      },
+    });
+
+    expect(extension).toBeDefined();
+
+    const { container } = createExtensionTester(extension).render();
+    expect(container.querySelector('h2')).toHaveTextContent('Hello, world!');
   });
 });

From ad4591af6615ac1e6281e424ea3b7ec90e9ca4f9 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Tue, 18 Jun 2024 13:29:57 +0200
Subject: [PATCH 03/14] chore: test creted extension Signed-off-by: blam
 <ben@blam.sh>

---
 .../src/wiring/createExtensionKind.test.tsx   | 26 ++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
index ea9459f3f6..2d5b218082 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
@@ -40,7 +40,31 @@ describe('createExtensionKind', () => {
       },
     });
 
-    expect(extension).toBeDefined();
+    expect(extension).toEqual({
+      $$type: '@backstage/ExtensionDefinition',
+      attachTo: {
+        id: 'test',
+        input: 'default',
+      },
+      configSchema: undefined,
+      disabled: false,
+      inputs: {},
+      kind: 'test-extension',
+      name: 'my-extension',
+      namespace: undefined,
+      output: {
+        element: {
+          $$type: '@backstage/ExtensionDataRef',
+          config: {},
+          id: 'core.reactElement',
+          optional: expect.any(Function),
+          toString: expect.any(Function),
+        },
+      },
+      factory: expect.any(Function),
+      toString: expect.any(Function),
+      version: 'v1',
+    });
 
     const { container } = createExtensionTester(extension).render();
     expect(container.querySelector('h1')).toHaveTextContent('Hello, world!');

From 71172a4caf3044b5379bd956c64d3535e1bc6528 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Tue, 18 Jun 2024 14:13:34 +0200
Subject: [PATCH 04/14] chore: added api-reports

Signed-off-by: blam <ben@blam.sh>
---
 packages/frontend-plugin-api/api-report.md    | 95 +++++++++++++++++++
 .../src/wiring/createExtensionKind.ts         | 13 ++-
 .../frontend-plugin-api/src/wiring/index.ts   |  5 +
 3 files changed, 111 insertions(+), 2 deletions(-)

diff --git a/packages/frontend-plugin-api/api-report.md b/packages/frontend-plugin-api/api-report.md
index 3e19573d95..b4c761ec05 100644
--- a/packages/frontend-plugin-api/api-report.md
+++ b/packages/frontend-plugin-api/api-report.md
@@ -522,6 +522,16 @@ export function createExtensionInput<
   }
 >;
 
+// @public
+export function createExtensionKind<
+  TProps,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+>(
+  options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>,
+): ExtensionKind<TProps, TInputs, TOutput, TConfig>;
+
 // @public (undocumented)
 export interface CreateExtensionOptions<
   TOutput extends AnyExtensionDataMap,
@@ -913,6 +923,91 @@ export interface ExtensionInput<
   extensionData: TExtensionData;
 }
 
+// @public (undocumented)
+export class ExtensionKind<
+  TProps,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  static create<
+    TProps,
+    TInputs extends AnyExtensionInputMap,
+    TOutput extends AnyExtensionDataMap,
+    TConfig,
+  >(
+    options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>,
+  ): ExtensionKind<TProps, TInputs, TOutput, TConfig>;
+  // (undocumented)
+  new(options: {
+    namespace?: string;
+    name?: string;
+    attachTo?: {
+      id: string;
+      input: string;
+    };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output?: TOutput;
+    configSchema?: PortableSchema<TConfig>;
+    props: TProps;
+    factory?(
+      options: {
+        node: AppNode;
+        config: TConfig;
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        orignalFactory(
+          options?: {
+            node?: AppNode;
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+          },
+          props?: TProps,
+        ): Expand<ExtensionDataValues<TOutput>>;
+      },
+      props: TProps,
+    ): Expand<ExtensionDataValues<TOutput>>;
+  }): ExtensionDefinition<TConfig>;
+}
+
+// @public (undocumented)
+export interface ExtensionKindOptions<
+  TProps,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  attachTo: {
+    id: string;
+    input: string;
+  };
+  // (undocumented)
+  configSchema?: PortableSchema<TConfig>;
+  // (undocumented)
+  disabled?: boolean;
+  // (undocumented)
+  factory(
+    options: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    },
+    props: TProps,
+  ): Expand<ExtensionDataValues<TOutput>>;
+  // (undocumented)
+  inputs?: TInputs;
+  // (undocumented)
+  kind: string;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
+  namespace?: string;
+  // (undocumented)
+  output: TOutput;
+}
+
 // @public (undocumented)
 export interface ExtensionOverrides {
   // (undocumented)
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
index 31a8e5da64..2067d18c04 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -24,7 +24,11 @@ import {
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-interface ExtensionKindOptions<
+
+/**
+ * @public
+ */
+export interface ExtensionKindOptions<
   TProps,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
@@ -48,7 +52,10 @@ interface ExtensionKindOptions<
   ): Expand<ExtensionDataValues<TOutput>>;
 }
 
-class ExtensionKind<
+/**
+ * @public
+ */
+export class ExtensionKind<
   TProps,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
@@ -153,6 +160,8 @@ class ExtensionKind<
 /**
  * A simpler replacement for wrapping up `createExtension` inside a kind or type. This allows for a cleaner API for creating
  * types and instances of those types.
+ *
+ * @public
  */
 export function createExtensionKind<
   TProps,
diff --git a/packages/frontend-plugin-api/src/wiring/index.ts b/packages/frontend-plugin-api/src/wiring/index.ts
index 61f821c7ce..e8c9afbaae 100644
--- a/packages/frontend-plugin-api/src/wiring/index.ts
+++ b/packages/frontend-plugin-api/src/wiring/index.ts
@@ -48,3 +48,8 @@ export {
   type FeatureFlagConfig,
   type FrontendFeature,
 } from './types';
+export {
+  type ExtensionKindOptions,
+  ExtensionKind,
+  createExtensionKind,
+} from './createExtensionKind';

From 4e53ad666d3c39d53ad4b81d7b6869a23dc1d5fa Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Tue, 18 Jun 2024 14:15:39 +0200
Subject: [PATCH 05/14] chore: add changeset

Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md | 26 ++++++++++++++++++++++++++
 1 file changed, 26 insertions(+)
 create mode 100644 .changeset/dry-squids-tap.md

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
new file mode 100644
index 0000000000..a9eb7efb3b
--- /dev/null
+++ b/.changeset/dry-squids-tap.md
@@ -0,0 +1,26 @@
+---
+'@backstage/frontend-plugin-api': patch
+---
+
+Introduce a new way to create extension types and kinds, with `createExtensionKind`.
+
+This allows the creation of extension with the following pattern:
+
+```tsx
+// create the extension kind
+const TestExtension = createExtensionKind({
+  kind: 'test-extension',
+  attachTo: { id: 'test', input: 'default' },
+  output: {
+    element: coreExtensionData.reactElement,
+  },
+  factory(_, props: { text: string }) {
+    return {
+      element: <h1>{props.text}</h1>,
+    };
+  },
+});
+
+// create an instance of the extension kind with props
+const testExtension = TestExtension.create({ text: 'Hello World' });
+```

From 546700b0c1acd565c089c6b8a9a89228d3f97909 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Wed, 26 Jun 2024 14:15:45 +0200
Subject: [PATCH 06/14] chore: some PR feedback suggestions

Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md                  |  9 +-
 packages/frontend-plugin-api/api-report.md    | 36 +++----
 .../src/wiring/createExtension.ts             |  4 +-
 .../src/wiring/createExtensionKind.test.tsx   | 17 ++--
 .../src/wiring/createExtensionKind.ts         | 93 ++++++++++---------
 .../frontend-plugin-api/src/wiring/index.ts   |  2 +-
 6 files changed, 84 insertions(+), 77 deletions(-)

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
index a9eb7efb3b..5193e1f204 100644
--- a/.changeset/dry-squids-tap.md
+++ b/.changeset/dry-squids-tap.md
@@ -8,7 +8,7 @@ This allows the creation of extension with the following pattern:
 
 ```tsx
 // create the extension kind
-const TestExtension = createExtensionKind({
+const TestExtensionKind = createExtensionKind({
   kind: 'test-extension',
   attachTo: { id: 'test', input: 'default' },
   output: {
@@ -22,5 +22,10 @@ const TestExtension = createExtensionKind({
 });
 
 // create an instance of the extension kind with props
-const testExtension = TestExtension.create({ text: 'Hello World' });
+const testExtension = TestExtensionKind.new({
+  name: 'foo',
+  options: {
+    text: 'Hello World',
+  },
+});
 ```
diff --git a/packages/frontend-plugin-api/api-report.md b/packages/frontend-plugin-api/api-report.md
index b4c761ec05..48718f5375 100644
--- a/packages/frontend-plugin-api/api-report.md
+++ b/packages/frontend-plugin-api/api-report.md
@@ -524,13 +524,13 @@ export function createExtensionInput<
 
 // @public
 export function createExtensionKind<
-  TProps,
+  TOptions,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 >(
-  options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>,
-): ExtensionKind<TProps, TInputs, TOutput, TConfig>;
+  options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
 
 // @public (undocumented)
 export interface CreateExtensionOptions<
@@ -548,7 +548,7 @@ export interface CreateExtensionOptions<
   // (undocumented)
   disabled?: boolean;
   // (undocumented)
-  factory(options: {
+  factory(context: {
     node: AppNode;
     config: TConfig;
     inputs: Expand<ResolvedExtensionInputs<TInputs>>;
@@ -923,24 +923,24 @@ export interface ExtensionInput<
   extensionData: TExtensionData;
 }
 
-// @public (undocumented)
+// @public
 export class ExtensionKind<
-  TProps,
+  TOptions,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 > {
   // (undocumented)
   static create<
-    TProps,
+    TOptions,
     TInputs extends AnyExtensionInputMap,
     TOutput extends AnyExtensionDataMap,
     TConfig,
   >(
-    options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>,
-  ): ExtensionKind<TProps, TInputs, TOutput, TConfig>;
+    options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+  ): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
   // (undocumented)
-  new(options: {
+  new(args: {
     namespace?: string;
     name?: string;
     attachTo?: {
@@ -951,29 +951,29 @@ export class ExtensionKind<
     inputs?: TInputs;
     output?: TOutput;
     configSchema?: PortableSchema<TConfig>;
-    props: TProps;
+    options: TOptions;
     factory?(
-      options: {
+      context: {
         node: AppNode;
         config: TConfig;
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
-          options?: {
+          context?: {
             node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
-          props?: TProps,
+          options?: TOptions,
         ): Expand<ExtensionDataValues<TOutput>>;
       },
-      props: TProps,
+      options: TOptions,
     ): Expand<ExtensionDataValues<TOutput>>;
   }): ExtensionDefinition<TConfig>;
 }
 
 // @public (undocumented)
 export interface ExtensionKindOptions<
-  TProps,
+  TOptions,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
@@ -989,12 +989,12 @@ export interface ExtensionKindOptions<
   disabled?: boolean;
   // (undocumented)
   factory(
-    options: {
+    context: {
       node: AppNode;
       config: TConfig;
       inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     },
-    props: TProps,
+    options: TOptions,
   ): Expand<ExtensionDataValues<TOutput>>;
   // (undocumented)
   inputs?: TInputs;
diff --git a/packages/frontend-plugin-api/src/wiring/createExtension.ts b/packages/frontend-plugin-api/src/wiring/createExtension.ts
index be76fbc069..28dc6a4e29 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtension.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtension.ts
@@ -91,7 +91,7 @@ export interface CreateExtensionOptions<
   inputs?: TInputs;
   output: TOutput;
   configSchema?: PortableSchema<TConfig>;
-  factory(options: {
+  factory(context: {
     node: AppNode;
     config: TConfig;
     inputs: Expand<ResolvedExtensionInputs<TInputs>>;
@@ -115,7 +115,7 @@ export interface InternalExtensionDefinition<TConfig>
   readonly version: 'v1';
   readonly inputs: AnyExtensionInputMap;
   readonly output: AnyExtensionDataMap;
-  factory(options: {
+  factory(context: {
     node: AppNode;
     config: TConfig;
     inputs: ResolvedExtensionInputs<any>;
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
index 2d5b218082..3bdcd3a7cc 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import React from 'react';
 import { coreExtensionData } from './coreExtensionData';
 import { createExtensionKind } from './createExtensionKind';
@@ -26,16 +27,16 @@ describe('createExtensionKind', () => {
       output: {
         element: coreExtensionData.reactElement,
       },
-      factory(_, props: { text: string }) {
+      factory(_, options: { text: string }) {
         return {
-          element: <h1>{props.text}</h1>,
+          element: <h1>{options.text}</h1>,
         };
       },
     });
 
     const extension = TestExtension.new({
       name: 'my-extension',
-      props: {
+      options: {
         text: 'Hello, world!',
       },
     });
@@ -77,21 +78,21 @@ describe('createExtensionKind', () => {
       output: {
         element: coreExtensionData.reactElement,
       },
-      factory(_, props: { text: string }) {
+      factory(_, options: { text: string }) {
         return {
-          element: <h1>{props.text}</h1>,
+          element: <h1>{options.text}</h1>,
         };
       },
     });
 
     const extension = TestExtension.new({
       name: 'my-extension',
-      props: {
+      options: {
         text: 'Hello, world!',
       },
-      factory(_, props: { text: string }) {
+      factory(_, options: { text: string }) {
         return {
-          element: <h2>{props.text}</h2>,
+          element: <h2>{options.text}</h2>,
         };
       },
     });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
index 2067d18c04..52bf711822 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -1,14 +1,3 @@
-import { AppNode } from '../apis';
-import { PortableSchema } from '../schema';
-import { Expand } from '../types';
-import {
-  AnyExtensionDataMap,
-  AnyExtensionInputMap,
-  ExtensionDataValues,
-  ResolvedExtensionInputs,
-  createExtension,
-} from './createExtension';
-
 /*
  * Copyright 2024 The Backstage Authors
  *
@@ -25,11 +14,22 @@ import {
  * limitations under the License.
  */
 
+import { AppNode } from '../apis';
+import { PortableSchema } from '../schema';
+import { Expand } from '../types';
+import {
+  AnyExtensionDataMap,
+  AnyExtensionInputMap,
+  ExtensionDataValues,
+  ResolvedExtensionInputs,
+  createExtension,
+} from './createExtension';
+
 /**
  * @public
  */
-export interface ExtensionKindOptions<
-  TProps,
+export interface CreateExtensionKindOptions<
+  TOptions,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
@@ -43,45 +43,46 @@ export interface ExtensionKindOptions<
   output: TOutput;
   configSchema?: PortableSchema<TConfig>;
   factory(
-    options: {
+    context: {
       node: AppNode;
       config: TConfig;
       inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     },
-    props: TProps,
+    options: TOptions,
   ): Expand<ExtensionDataValues<TOutput>>;
 }
 
 /**
+ * TODO: should we export an interface instead of a concrete class?
  * @public
  */
 export class ExtensionKind<
-  TProps,
+  TOptions,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 > {
   static create<
-    TProps,
+    TOptions,
     TInputs extends AnyExtensionInputMap,
     TOutput extends AnyExtensionDataMap,
     TConfig,
   >(
-    options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>,
-  ): ExtensionKind<TProps, TInputs, TOutput, TConfig> {
+    options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+  ): ExtensionKind<TOptions, TInputs, TOutput, TConfig> {
     return new ExtensionKind(options);
   }
 
   private constructor(
-    private readonly options: ExtensionKindOptions<
-      TProps,
+    private readonly options: CreateExtensionKindOptions<
+      TOptions,
       TInputs,
       TOutput,
       TConfig
     >,
   ) {}
 
-  public new(options: {
+  public new(args: {
     namespace?: string;
     name?: string;
     attachTo?: { id: string; input: string };
@@ -89,58 +90,58 @@ export class ExtensionKind<
     inputs?: TInputs;
     output?: TOutput;
     configSchema?: PortableSchema<TConfig>;
-    props: TProps;
+    options: TOptions;
     factory?(
-      options: {
+      context: {
         node: AppNode;
         config: TConfig;
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
-          options?: {
+          context?: {
             node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
-          props?: TProps,
+          options?: TOptions,
         ): Expand<ExtensionDataValues<TOutput>>;
       },
-      props: TProps,
+      options: TOptions,
     ): Expand<ExtensionDataValues<TOutput>>;
   }) {
     return createExtension({
       kind: this.options.kind,
-      namespace: options.namespace ?? this.options.namespace,
-      name: options.name ?? this.options.name,
-      attachTo: options.attachTo ?? this.options.attachTo,
-      disabled: options.disabled ?? this.options.disabled,
-      inputs: options.inputs ?? this.options.inputs,
-      output: options.output ?? this.options.output,
-      configSchema: options.configSchema ?? this.options.configSchema, // TODO: some config merging or smth
+      namespace: args.namespace ?? this.options.namespace,
+      name: args.name ?? this.options.name,
+      attachTo: args.attachTo ?? this.options.attachTo,
+      disabled: args.disabled ?? this.options.disabled,
+      inputs: args.inputs ?? this.options.inputs,
+      output: args.output ?? this.options.output,
+      configSchema: args.configSchema ?? this.options.configSchema, // TODO: some config merging or smth
       factory: ({ node, config, inputs }) => {
-        if (options.factory) {
-          return options.factory(
+        if (args.factory) {
+          return args.factory(
             {
               node,
               config,
               inputs,
               orignalFactory: (
-                innerOptions?: {
+                innerContext?: {
                   node?: AppNode;
                   config?: TConfig;
                   inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
                 },
-                innerProps?: TProps,
+                innerOptions?: TOptions,
               ) =>
                 this.options.factory(
                   {
-                    node: innerOptions?.node ?? node,
-                    config: innerOptions?.config ?? config,
-                    inputs: innerOptions?.inputs ?? inputs,
+                    node: innerContext?.node ?? node,
+                    config: innerContext?.config ?? config,
+                    inputs: innerContext?.inputs ?? inputs,
                   },
-                  innerProps ?? options.props,
+                  innerOptions ?? args.options,
                 ),
             },
-            options.props,
+            args.options,
           );
         }
 
@@ -150,7 +151,7 @@ export class ExtensionKind<
             config,
             inputs,
           },
-          options.props,
+          args.options,
         );
       },
     });
@@ -164,10 +165,10 @@ export class ExtensionKind<
  * @public
  */
 export function createExtensionKind<
-  TProps,
+  TOptions,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
->(options: ExtensionKindOptions<TProps, TInputs, TOutput, TConfig>) {
+>(options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>) {
   return ExtensionKind.create(options);
 }
diff --git a/packages/frontend-plugin-api/src/wiring/index.ts b/packages/frontend-plugin-api/src/wiring/index.ts
index e8c9afbaae..8fe9dc3a54 100644
--- a/packages/frontend-plugin-api/src/wiring/index.ts
+++ b/packages/frontend-plugin-api/src/wiring/index.ts
@@ -49,7 +49,7 @@ export {
   type FrontendFeature,
 } from './types';
 export {
-  type ExtensionKindOptions,
+  type CreateExtensionKindOptions as ExtensionKindOptions,
   ExtensionKind,
   createExtensionKind,
 } from './createExtensionKind';

From 1f5094f1b70495aba6ee8d54bb86ed5dcea6b410 Mon Sep 17 00:00:00 2001
From: Ben Lambert <blam@spotify.com>
Date: Wed, 26 Jun 2024 16:20:47 +0200
Subject: [PATCH 07/14] Update dry-squids-tap.md

Signed-off-by: Ben Lambert <blam@spotify.com>
Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
index 5193e1f204..9bd835d371 100644
--- a/.changeset/dry-squids-tap.md
+++ b/.changeset/dry-squids-tap.md
@@ -14,9 +14,9 @@ const TestExtensionKind = createExtensionKind({
   output: {
     element: coreExtensionData.reactElement,
   },
-  factory(_, props: { text: string }) {
+  factory(_, options: { text: string }) {
     return {
-      element: <h1>{props.text}</h1>,
+      element: <h1>{options.text}</h1>,
     };
   },
 });

From f749bb8fa989e5f4c29608a903cc9119cd745390 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Tue, 25 Jun 2024 14:25:22 +0200
Subject: [PATCH 08/14] chore: extension overrides spike

Signed-off-by: blam <ben@blam.sh>
---
 .../core-compat-api/src/convertLegacyApp.ts   |  72 ++++++++++-
 .../src/wiring/createExtension.test.ts        |  33 +++++
 .../src/wiring/createExtension.ts             | 121 ++++++++++++++----
 .../src/wiring/createExtensionKind.ts         |   4 +-
 4 files changed, 194 insertions(+), 36 deletions(-)

diff --git a/packages/core-compat-api/src/convertLegacyApp.ts b/packages/core-compat-api/src/convertLegacyApp.ts
index 72ce4b5e61..567e5efcad 100644
--- a/packages/core-compat-api/src/convertLegacyApp.ts
+++ b/packages/core-compat-api/src/convertLegacyApp.ts
@@ -26,6 +26,7 @@ import {
   coreExtensionData,
   createExtension,
   createExtensionInput,
+  createExtensionKind,
   createExtensionOverrides,
 } from '@backstage/frontend-plugin-api';
 import { getComponentData } from '@backstage/core-plugin-api';
@@ -128,21 +129,80 @@ export function convertLegacyApp(
       };
     },
   });
-  const CoreNavOverride = createExtension({
-    namespace: 'app',
-    name: 'nav',
-    attachTo: { id: 'app/layout', input: 'nav' },
-    output: {},
+
+  const CoreNavOverride = CurrentCoreNav.override({
+    // namespace: 'app',
+    // name: 'nav',
+    // attachTo: { id: 'app/layout', input: 'nav' },
+    // output: {},
     factory: () => ({}),
     disabled: true,
   });
 
+  createExtensionOverride({
+    extension: CurrentCoreNav,
+    factory: () => null,
+  });
+
   const collectedRoutes = collectLegacyRoutes(routesEl);
 
   return [
     ...collectedRoutes,
     createExtensionOverrides({
-      extensions: [CoreLayoutOverride, CoreNavOverride],
+      extensions: [CoreNavOverride, CoreNavOverride],
     }),
   ];
 }
+
+const EntityCardExtension = createExtensionKind({
+  kind: 'entity-card',
+  attachTo: { id: 'entity-card', input: 'default' },
+  inputs: {
+    loader: createExtensionInput({
+      element: coreExtensionData.reactElement,
+    }),
+  },
+  output: {
+    element: coreExtensionData.reactElement,
+  },
+  factory({ inputs }, props: { title: string }) {
+    console.log(inputs.loader);
+    return {
+      element: React.createElement('h1'),
+    };
+  },
+});
+
+const GithubCard = EntityCardExtension.new({
+  props: {
+    title: 'GitHub Card',
+  },
+  factory({ inputs: { loader } }) {
+    console.log(loader);
+    return {
+      element: React.createElement('h2'),
+    };
+  },
+});
+
+GithubCard.override({
+  attachTo: { id: 'entity-card', input: 'github' },
+  inputs: {
+    loader: createExtensionInput(
+      {
+        element: coreExtensionData.reactElement,
+      },
+      { singleton: false },
+    ),
+    loader2: createExtensionInput({
+      element: coreExtensionData.reactElement,
+    }),
+  },
+  factory({ originalFactory, inputs }) {
+    inputs.loader2;
+    inputs.loader;
+    return originalFactory({
+      inputsOverride: inputs,
+    });
+  },
+});
diff --git a/packages/frontend-plugin-api/src/wiring/createExtension.test.ts b/packages/frontend-plugin-api/src/wiring/createExtension.test.ts
index 42ab21db80..cfef69b0fe 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtension.test.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtension.test.ts
@@ -291,4 +291,37 @@ describe('createExtension', () => {
       'ExtensionDefinition{namespace=test,attachTo=root@default}',
     );
   });
+
+  describe('override', () => {
+    it('should create an extension override', () => {
+      const extension = createExtension({
+        namespace: 'test',
+        attachTo: { id: 'root', input: 'default' },
+        output: {
+          foo: stringData,
+        },
+        factory() {
+          return {
+            foo: 'bar',
+          };
+        },
+      });
+
+      const override = extension.override({
+        attachTo: {
+          id: 'root',
+          input: 'default2',
+        },
+        factory() {
+          return {
+            foo: 'baz',
+          };
+        },
+      });
+
+      expect(String(override)).toBe(
+        'ExtensionDefinition{namespace=test,attachTo=root@default2}',
+      );
+    });
+  });
 });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtension.ts b/packages/frontend-plugin-api/src/wiring/createExtension.ts
index 28dc6a4e29..b56cc39fc9 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtension.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtension.ts
@@ -99,7 +99,33 @@ export interface CreateExtensionOptions<
 }
 
 /** @public */
-export interface ExtensionDefinition<TConfig> {
+export interface ExtensionDefinitionOverrides<
+  TOriginalConfig,
+  TOriginalInputs extends AnyExtensionInputMap,
+  TOverrideInputs extends AnyExtensionInputMap,
+> {
+  readonly disabled?: boolean;
+  readonly attachTo?: { id: string; input: string };
+  // TODO: inputs (only adding to the list? or redefine arity and superset of old type on existing input?)
+  // TODO: config (any merging needed on there?)
+  inputs?: TOverrideInputs;
+  factory?(options: {
+    node: AppNode;
+    config: TOriginalConfig;
+    inputs: Expand<ResolvedExtensionInputs<TOriginalInputs & TOverrideInputs>>;
+    originalFactory: (originalFactoryOptions?: {
+      inputsOverride?: ResolvedExtensionInputs<
+        TOriginalInputs & TOverrideInputs
+      >;
+    }) => ExtensionDataValues<any>;
+  }): ExtensionDataValues<any>;
+}
+
+/** @public */
+export interface ExtensionDefinition<
+  TConfig,
+  TInputs extends AnyExtensionInputMap,
+> {
   $$type: '@backstage/ExtensionDefinition';
   readonly kind?: string;
   readonly namespace?: string;
@@ -107,13 +133,18 @@ export interface ExtensionDefinition<TConfig> {
   readonly attachTo: { id: string; input: string };
   readonly disabled: boolean;
   readonly configSchema?: PortableSchema<TConfig>;
+  override<TOverrideInputs extends AnyExtensionInputMap>(
+    overrides: ExtensionDefinitionOverrides<TConfig, TInputs, TOverrideInputs>,
+  ): ExtensionDefinition<TConfig, TInputs>;
 }
 
 /** @internal */
-export interface InternalExtensionDefinition<TConfig>
-  extends ExtensionDefinition<TConfig> {
+export interface InternalExtensionDefinition<
+  TConfig,
+  TInputs extends AnyExtensionInputMap,
+> extends ExtensionDefinition<TConfig, TInputs> {
   readonly version: 'v1';
-  readonly inputs: AnyExtensionInputMap;
+  readonly inputs: TInputs;
   readonly output: AnyExtensionDataMap;
   factory(context: {
     node: AppNode;
@@ -123,10 +154,13 @@ export interface InternalExtensionDefinition<TConfig>
 }
 
 /** @internal */
-export function toInternalExtensionDefinition<TConfig>(
-  overrides: ExtensionDefinition<TConfig>,
-): InternalExtensionDefinition<TConfig> {
-  const internal = overrides as InternalExtensionDefinition<TConfig>;
+export function toInternalExtensionDefinition<
+  TConfig,
+  TInputs extends AnyExtensionInputMap,
+>(
+  overrides: ExtensionDefinition<TConfig, TInputs>,
+): InternalExtensionDefinition<TConfig, TInputs> {
+  const internal = overrides as InternalExtensionDefinition<TConfig, TInputs>;
   if (internal.$$type !== '@backstage/ExtensionDefinition') {
     throw new Error(
       `Invalid extension definition instance, bad type '${internal.$$type}'`,
@@ -147,38 +181,69 @@ export function createExtension<
   TConfig = never,
 >(
   options: CreateExtensionOptions<TOutput, TInputs, TConfig>,
-): ExtensionDefinition<TConfig> {
+): ExtensionDefinition<TConfig, TInputs> {
+  const {
+    kind,
+    namespace,
+    name,
+    attachTo,
+    disabled = false,
+    inputs = {} as TInputs,
+    output,
+    configSchema,
+    factory,
+  } = options;
+
   return {
     $$type: '@backstage/ExtensionDefinition',
     version: 'v1',
-    kind: options.kind,
-    namespace: options.namespace,
-    name: options.name,
-    attachTo: options.attachTo,
-    disabled: options.disabled ?? false,
-    inputs: options.inputs ?? {},
-    output: options.output,
-    configSchema: options.configSchema,
-    factory({ inputs, ...rest }) {
+    kind,
+    namespace,
+    name,
+    attachTo,
+    disabled,
+    inputs,
+    output,
+    configSchema,
+    factory({ inputs: factoryInputs, ...rest }) {
       // TODO: Simplify this, but TS wouldn't infer the input type for some reason
-      return options.factory({
-        inputs: inputs as Expand<ResolvedExtensionInputs<TInputs>>,
+      return factory({
+        inputs: factoryInputs as Expand<ResolvedExtensionInputs<TInputs>>,
         ...rest,
       });
     },
     toString() {
       const parts: string[] = [];
-      if (options.kind) {
-        parts.push(`kind=${options.kind}`);
+      if (kind) {
+        parts.push(`kind=${kind}`);
       }
-      if (options.namespace) {
-        parts.push(`namespace=${options.namespace}`);
+      if (namespace) {
+        parts.push(`namespace=${namespace}`);
       }
-      if (options.name) {
-        parts.push(`name=${options.name}`);
+      if (name) {
+        parts.push(`name=${name}`);
       }
-      parts.push(`attachTo=${options.attachTo.id}@${options.attachTo.input}`);
+      parts.push(`attachTo=${attachTo.id}@${attachTo.input}`);
       return `ExtensionDefinition{${parts.join(',')}}`;
     },
-  } as InternalExtensionDefinition<TConfig>;
+    override<TOverrideInputs extends AnyExtensionInputMap>(
+      overrides: ExtensionDefinitionOverrides<
+        TConfig,
+        TInputs,
+        TOverrideInputs
+      >,
+    ): ExtensionDefinition<TConfig, TInputs> {
+      return createExtension({
+        kind,
+        namespace,
+        name,
+        attachTo: overrides.attachTo ?? attachTo,
+        disabled: overrides.disabled ?? disabled,
+        inputs: { ...inputs, ...overrides.inputs },
+        output,
+        configSchema,
+        factory,
+      });
+    },
+  } as InternalExtensionDefinition<TConfig, TInputs>;
 }
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
index 52bf711822..353fb8ab70 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -13,7 +13,6 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-
 import { AppNode } from '../apis';
 import { PortableSchema } from '../schema';
 import { Expand } from '../types';
@@ -21,6 +20,7 @@ import {
   AnyExtensionDataMap,
   AnyExtensionInputMap,
   ExtensionDataValues,
+  ExtensionDefinition,
   ResolvedExtensionInputs,
   createExtension,
 } from './createExtension';
@@ -107,7 +107,7 @@ export class ExtensionKind<
       },
       options: TOptions,
     ): Expand<ExtensionDataValues<TOutput>>;
-  }) {
+  }): ExtensionDefinition<TConfig, TInputs> {
     return createExtension({
       kind: this.options.kind,
       namespace: args.namespace ?? this.options.namespace,

From 966cca176bc0506034499ce2cb622ebdffe2ca1b Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Wed, 26 Jun 2024 16:31:25 +0200
Subject: [PATCH 09/14] chore: tidying up Signed-off-by: blam <ben@blam.sh>

Signed-off-by: blam <ben@blam.sh>
---
 .../core-compat-api/src/convertLegacyApp.ts   |  72 +----
 packages/frontend-plugin-api/api-report.md    | 214 ++++++++++-----
 .../src/wiring/createExtension.test.ts        |  33 ---
 .../src/wiring/createExtension.ts             | 125 +++------
 .../src/wiring/createExtensionKind.test.tsx   | 164 ++++++++++++
 .../src/wiring/createExtensionKind.ts         | 245 ++++++++++++++----
 .../frontend-plugin-api/src/wiring/index.ts   |   4 +-
 7 files changed, 550 insertions(+), 307 deletions(-)

diff --git a/packages/core-compat-api/src/convertLegacyApp.ts b/packages/core-compat-api/src/convertLegacyApp.ts
index 567e5efcad..72ce4b5e61 100644
--- a/packages/core-compat-api/src/convertLegacyApp.ts
+++ b/packages/core-compat-api/src/convertLegacyApp.ts
@@ -26,7 +26,6 @@ import {
   coreExtensionData,
   createExtension,
   createExtensionInput,
-  createExtensionKind,
   createExtensionOverrides,
 } from '@backstage/frontend-plugin-api';
 import { getComponentData } from '@backstage/core-plugin-api';
@@ -129,80 +128,21 @@ export function convertLegacyApp(
       };
     },
   });
-
-  const CoreNavOverride = CurrentCoreNav.override({
-    // namespace: 'app',
-    // name: 'nav',
-    // attachTo: { id: 'app/layout', input: 'nav' },
-    // output: {},
+  const CoreNavOverride = createExtension({
+    namespace: 'app',
+    name: 'nav',
+    attachTo: { id: 'app/layout', input: 'nav' },
+    output: {},
     factory: () => ({}),
     disabled: true,
   });
 
-  createExtensionOverride({
-    extension: CurrentCoreNav,
-    factory: () => null,
-  });
-
   const collectedRoutes = collectLegacyRoutes(routesEl);
 
   return [
     ...collectedRoutes,
     createExtensionOverrides({
-      extensions: [CoreNavOverride, CoreNavOverride],
+      extensions: [CoreLayoutOverride, CoreNavOverride],
     }),
   ];
 }
-
-const EntityCardExtension = createExtensionKind({
-  kind: 'entity-card',
-  attachTo: { id: 'entity-card', input: 'default' },
-  inputs: {
-    loader: createExtensionInput({
-      element: coreExtensionData.reactElement,
-    }),
-  },
-  output: {
-    element: coreExtensionData.reactElement,
-  },
-  factory({ inputs }, props: { title: string }) {
-    console.log(inputs.loader);
-    return {
-      element: React.createElement('h1'),
-    };
-  },
-});
-
-const GithubCard = EntityCardExtension.new({
-  props: {
-    title: 'GitHub Card',
-  },
-  factory({ inputs: { loader } }) {
-    console.log(loader);
-    return {
-      element: React.createElement('h2'),
-    };
-  },
-});
-
-GithubCard.override({
-  attachTo: { id: 'entity-card', input: 'github' },
-  inputs: {
-    loader: createExtensionInput(
-      {
-        element: coreExtensionData.reactElement,
-      },
-      { singleton: false },
-    ),
-    loader2: createExtensionInput({
-      element: coreExtensionData.reactElement,
-    }),
-  },
-  factory({ originalFactory, inputs }) {
-    inputs.loader2;
-    inputs.loader;
-    return originalFactory({
-      inputsOverride: inputs,
-    });
-  },
-});
diff --git a/packages/frontend-plugin-api/api-report.md b/packages/frontend-plugin-api/api-report.md
index 48718f5375..6a04d04cd6 100644
--- a/packages/frontend-plugin-api/api-report.md
+++ b/packages/frontend-plugin-api/api-report.md
@@ -529,9 +529,91 @@ export function createExtensionKind<
   TOutput extends AnyExtensionDataMap,
   TConfig,
 >(
-  options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+  options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
 ): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
 
+// @public (undocumented)
+export interface CreateExtensionKindInstanceOptions<
+  TOptions,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  attachTo?: {
+    id: string;
+    input: string;
+  };
+  // (undocumented)
+  configSchema?: PortableSchema<TConfig>;
+  // (undocumented)
+  disabled?: boolean;
+  // (undocumented)
+  factory?(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+      originalFactory(
+        context?: {
+          node?: AppNode;
+          config?: TConfig;
+          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+        },
+        options?: TOptions,
+      ): Expand<ExtensionDataValues<TOutput>>;
+    },
+    options: TOptions,
+  ): Expand<ExtensionDataValues<TOutput>>;
+  // (undocumented)
+  inputs?: TInputs;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
+  namespace?: string;
+  // (undocumented)
+  options: TOptions;
+  // (undocumented)
+  output?: TOutput;
+}
+
+// @public (undocumented)
+export interface CreateExtensionKindOptions<
+  TOptions,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  attachTo: {
+    id: string;
+    input: string;
+  };
+  // (undocumented)
+  configSchema?: PortableSchema<TConfig>;
+  // (undocumented)
+  disabled?: boolean;
+  // (undocumented)
+  factory(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    },
+    options: TOptions,
+  ): Expand<ExtensionDataValues<TOutput>>;
+  // (undocumented)
+  inputs?: TInputs;
+  // (undocumented)
+  kind: string;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
+  namespace?: string;
+  // (undocumented)
+  output: TOutput;
+}
+
 // @public (undocumented)
 export interface CreateExtensionOptions<
   TOutput extends AnyExtensionDataMap,
@@ -548,7 +630,7 @@ export interface CreateExtensionOptions<
   // (undocumented)
   disabled?: boolean;
   // (undocumented)
-  factory(context: {
+  factory(options: {
     node: AppNode;
     config: TConfig;
     inputs: Expand<ResolvedExtensionInputs<TInputs>>;
@@ -565,6 +647,51 @@ export interface CreateExtensionOptions<
   output: TOutput;
 }
 
+// @public (undocumented)
+export interface CreateExtensionOverrideKindInstanceOptions<
+  TOptions,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  attachTo?: {
+    id: string;
+    input: string;
+  };
+  // (undocumented)
+  configSchema?: PortableSchema<TConfig>;
+  // (undocumented)
+  disabled?: boolean;
+  // (undocumented)
+  factory?(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+      originalFactory(
+        context?: {
+          node?: AppNode;
+          config?: TConfig;
+          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+        },
+        options?: TOptions,
+      ): Expand<ExtensionDataValues<TOutput>>;
+    },
+    options: TOptions,
+  ): Expand<ExtensionDataValues<TOutput>>;
+  // (undocumented)
+  inputs?: TInputs;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
+  namespace?: string;
+  // (undocumented)
+  options?: TOptions;
+  // (undocumented)
+  output?: TOutput;
+}
+
 // @public (undocumented)
 export function createExtensionOverrides(
   options: ExtensionOverridesOptions,
@@ -937,75 +1064,26 @@ export class ExtensionKind<
     TOutput extends AnyExtensionDataMap,
     TConfig,
   >(
-    options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+    options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
   ): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
   // (undocumented)
-  new(args: {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-      id: string;
-      input: string;
-    };
-    disabled?: boolean;
-    inputs?: TInputs;
-    output?: TOutput;
-    configSchema?: PortableSchema<TConfig>;
-    options: TOptions;
-    factory?(
-      context: {
-        node: AppNode;
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        orignalFactory(
-          context?: {
-            node?: AppNode;
-            config?: TConfig;
-            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-          },
-          options?: TOptions,
-        ): Expand<ExtensionDataValues<TOutput>>;
-      },
-      options: TOptions,
-    ): Expand<ExtensionDataValues<TOutput>>;
-  }): ExtensionDefinition<TConfig>;
-}
-
-// @public (undocumented)
-export interface ExtensionKindOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  // (undocumented)
-  attachTo: {
-    id: string;
-    input: string;
+  new(
+    instanceProperties: CreateExtensionKindInstanceOptions<
+      TOptions,
+      TInputs,
+      TOutput,
+      TConfig
+    >,
+  ): ExtensionDefinition<TConfig> & {
+    override: (
+      overrides: CreateExtensionOverrideKindInstanceOptions<
+        TOptions,
+        TInputs,
+        TOutput,
+        TConfig
+      >,
+    ) => ExtensionDefinition<TConfig>;
   };
-  // (undocumented)
-  configSchema?: PortableSchema<TConfig>;
-  // (undocumented)
-  disabled?: boolean;
-  // (undocumented)
-  factory(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-  // (undocumented)
-  inputs?: TInputs;
-  // (undocumented)
-  kind: string;
-  // (undocumented)
-  name?: string;
-  // (undocumented)
-  namespace?: string;
-  // (undocumented)
-  output: TOutput;
 }
 
 // @public (undocumented)
diff --git a/packages/frontend-plugin-api/src/wiring/createExtension.test.ts b/packages/frontend-plugin-api/src/wiring/createExtension.test.ts
index cfef69b0fe..42ab21db80 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtension.test.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtension.test.ts
@@ -291,37 +291,4 @@ describe('createExtension', () => {
       'ExtensionDefinition{namespace=test,attachTo=root@default}',
     );
   });
-
-  describe('override', () => {
-    it('should create an extension override', () => {
-      const extension = createExtension({
-        namespace: 'test',
-        attachTo: { id: 'root', input: 'default' },
-        output: {
-          foo: stringData,
-        },
-        factory() {
-          return {
-            foo: 'bar',
-          };
-        },
-      });
-
-      const override = extension.override({
-        attachTo: {
-          id: 'root',
-          input: 'default2',
-        },
-        factory() {
-          return {
-            foo: 'baz',
-          };
-        },
-      });
-
-      expect(String(override)).toBe(
-        'ExtensionDefinition{namespace=test,attachTo=root@default2}',
-      );
-    });
-  });
 });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtension.ts b/packages/frontend-plugin-api/src/wiring/createExtension.ts
index b56cc39fc9..be76fbc069 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtension.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtension.ts
@@ -91,7 +91,7 @@ export interface CreateExtensionOptions<
   inputs?: TInputs;
   output: TOutput;
   configSchema?: PortableSchema<TConfig>;
-  factory(context: {
+  factory(options: {
     node: AppNode;
     config: TConfig;
     inputs: Expand<ResolvedExtensionInputs<TInputs>>;
@@ -99,33 +99,7 @@ export interface CreateExtensionOptions<
 }
 
 /** @public */
-export interface ExtensionDefinitionOverrides<
-  TOriginalConfig,
-  TOriginalInputs extends AnyExtensionInputMap,
-  TOverrideInputs extends AnyExtensionInputMap,
-> {
-  readonly disabled?: boolean;
-  readonly attachTo?: { id: string; input: string };
-  // TODO: inputs (only adding to the list? or redefine arity and superset of old type on existing input?)
-  // TODO: config (any merging needed on there?)
-  inputs?: TOverrideInputs;
-  factory?(options: {
-    node: AppNode;
-    config: TOriginalConfig;
-    inputs: Expand<ResolvedExtensionInputs<TOriginalInputs & TOverrideInputs>>;
-    originalFactory: (originalFactoryOptions?: {
-      inputsOverride?: ResolvedExtensionInputs<
-        TOriginalInputs & TOverrideInputs
-      >;
-    }) => ExtensionDataValues<any>;
-  }): ExtensionDataValues<any>;
-}
-
-/** @public */
-export interface ExtensionDefinition<
-  TConfig,
-  TInputs extends AnyExtensionInputMap,
-> {
+export interface ExtensionDefinition<TConfig> {
   $$type: '@backstage/ExtensionDefinition';
   readonly kind?: string;
   readonly namespace?: string;
@@ -133,20 +107,15 @@ export interface ExtensionDefinition<
   readonly attachTo: { id: string; input: string };
   readonly disabled: boolean;
   readonly configSchema?: PortableSchema<TConfig>;
-  override<TOverrideInputs extends AnyExtensionInputMap>(
-    overrides: ExtensionDefinitionOverrides<TConfig, TInputs, TOverrideInputs>,
-  ): ExtensionDefinition<TConfig, TInputs>;
 }
 
 /** @internal */
-export interface InternalExtensionDefinition<
-  TConfig,
-  TInputs extends AnyExtensionInputMap,
-> extends ExtensionDefinition<TConfig, TInputs> {
+export interface InternalExtensionDefinition<TConfig>
+  extends ExtensionDefinition<TConfig> {
   readonly version: 'v1';
-  readonly inputs: TInputs;
+  readonly inputs: AnyExtensionInputMap;
   readonly output: AnyExtensionDataMap;
-  factory(context: {
+  factory(options: {
     node: AppNode;
     config: TConfig;
     inputs: ResolvedExtensionInputs<any>;
@@ -154,13 +123,10 @@ export interface InternalExtensionDefinition<
 }
 
 /** @internal */
-export function toInternalExtensionDefinition<
-  TConfig,
-  TInputs extends AnyExtensionInputMap,
->(
-  overrides: ExtensionDefinition<TConfig, TInputs>,
-): InternalExtensionDefinition<TConfig, TInputs> {
-  const internal = overrides as InternalExtensionDefinition<TConfig, TInputs>;
+export function toInternalExtensionDefinition<TConfig>(
+  overrides: ExtensionDefinition<TConfig>,
+): InternalExtensionDefinition<TConfig> {
+  const internal = overrides as InternalExtensionDefinition<TConfig>;
   if (internal.$$type !== '@backstage/ExtensionDefinition') {
     throw new Error(
       `Invalid extension definition instance, bad type '${internal.$$type}'`,
@@ -181,69 +147,38 @@ export function createExtension<
   TConfig = never,
 >(
   options: CreateExtensionOptions<TOutput, TInputs, TConfig>,
-): ExtensionDefinition<TConfig, TInputs> {
-  const {
-    kind,
-    namespace,
-    name,
-    attachTo,
-    disabled = false,
-    inputs = {} as TInputs,
-    output,
-    configSchema,
-    factory,
-  } = options;
-
+): ExtensionDefinition<TConfig> {
   return {
     $$type: '@backstage/ExtensionDefinition',
     version: 'v1',
-    kind,
-    namespace,
-    name,
-    attachTo,
-    disabled,
-    inputs,
-    output,
-    configSchema,
-    factory({ inputs: factoryInputs, ...rest }) {
+    kind: options.kind,
+    namespace: options.namespace,
+    name: options.name,
+    attachTo: options.attachTo,
+    disabled: options.disabled ?? false,
+    inputs: options.inputs ?? {},
+    output: options.output,
+    configSchema: options.configSchema,
+    factory({ inputs, ...rest }) {
       // TODO: Simplify this, but TS wouldn't infer the input type for some reason
-      return factory({
-        inputs: factoryInputs as Expand<ResolvedExtensionInputs<TInputs>>,
+      return options.factory({
+        inputs: inputs as Expand<ResolvedExtensionInputs<TInputs>>,
         ...rest,
       });
     },
     toString() {
       const parts: string[] = [];
-      if (kind) {
-        parts.push(`kind=${kind}`);
+      if (options.kind) {
+        parts.push(`kind=${options.kind}`);
       }
-      if (namespace) {
-        parts.push(`namespace=${namespace}`);
+      if (options.namespace) {
+        parts.push(`namespace=${options.namespace}`);
       }
-      if (name) {
-        parts.push(`name=${name}`);
+      if (options.name) {
+        parts.push(`name=${options.name}`);
       }
-      parts.push(`attachTo=${attachTo.id}@${attachTo.input}`);
+      parts.push(`attachTo=${options.attachTo.id}@${options.attachTo.input}`);
       return `ExtensionDefinition{${parts.join(',')}}`;
     },
-    override<TOverrideInputs extends AnyExtensionInputMap>(
-      overrides: ExtensionDefinitionOverrides<
-        TConfig,
-        TInputs,
-        TOverrideInputs
-      >,
-    ): ExtensionDefinition<TConfig, TInputs> {
-      return createExtension({
-        kind,
-        namespace,
-        name,
-        attachTo: overrides.attachTo ?? attachTo,
-        disabled: overrides.disabled ?? disabled,
-        inputs: { ...inputs, ...overrides.inputs },
-        output,
-        configSchema,
-        factory,
-      });
-    },
-  } as InternalExtensionDefinition<TConfig, TInputs>;
+  } as InternalExtensionDefinition<TConfig>;
 }
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
index 3bdcd3a7cc..30c3e6ca44 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
@@ -64,6 +64,7 @@ describe('createExtensionKind', () => {
       },
       factory: expect.any(Function),
       toString: expect.any(Function),
+      override: expect.any(Function),
       version: 'v1',
     });
 
@@ -102,4 +103,167 @@ describe('createExtensionKind', () => {
     const { container } = createExtensionTester(extension).render();
     expect(container.querySelector('h2')).toHaveTextContent('Hello, world!');
   });
+
+  it('should allow calling of the default value from override', () => {
+    const TestExtension = createExtensionKind({
+      kind: 'test-extension',
+      attachTo: { id: 'test', input: 'default' },
+      output: {
+        element: coreExtensionData.reactElement,
+      },
+      factory(_, options: { text: string }) {
+        return {
+          element: <h1>{options.text}</h1>,
+        };
+      },
+    });
+
+    const extension = TestExtension.new({
+      name: 'my-extension',
+      options: {
+        text: 'Hello, world!',
+      },
+      factory({ originalFactory }, options: { text: string }) {
+        const { element } = originalFactory();
+        return {
+          element: (
+            <h2>
+              {options.text}
+              {element}
+            </h2>
+          ),
+        };
+      },
+    });
+
+    expect(extension).toBeDefined();
+
+    const { container } = createExtensionTester(extension).render();
+
+    expect(container.querySelector('h2 h1')).toHaveTextContent('Hello, world!');
+  });
+
+  it('should allow overriding options of the default value from override', () => {
+    const TestExtension = createExtensionKind({
+      kind: 'test-extension',
+      attachTo: { id: 'test', input: 'default' },
+      output: {
+        element: coreExtensionData.reactElement,
+      },
+      factory(_, options: { text: string }) {
+        return {
+          element: <h1>{options.text}</h1>,
+        };
+      },
+    });
+
+    const extension = TestExtension.new({
+      name: 'my-extension',
+      options: {
+        text: 'Hello, world!',
+      },
+      factory({ originalFactory }, options: { text: string }) {
+        const { element } = originalFactory(undefined, { text: 'nothing!' });
+        return {
+          element: (
+            <h2>
+              {options.text}
+              {element}
+            </h2>
+          ),
+        };
+      },
+    });
+
+    expect(extension).toBeDefined();
+
+    const { container } = createExtensionTester(extension).render();
+
+    expect(container.querySelector('h2 h1')).toHaveTextContent('nothing!');
+  });
+
+  describe('override', () => {
+    it('should allow overriding of the default factory', () => {
+      const TestExtension = createExtensionKind({
+        kind: 'test-extension',
+        attachTo: { id: 'test', input: 'default' },
+        output: {
+          element: coreExtensionData.reactElement,
+        },
+        factory(_, options: { text: string }) {
+          return {
+            element: <h1>{options.text}</h1>,
+          };
+        },
+      });
+
+      const extension = TestExtension.new({
+        name: 'my-extension',
+        options: {
+          text: 'Hello, world!',
+        },
+        factory(_, options: { text: string }) {
+          return {
+            element: <h2>{options.text}</h2>,
+          };
+        },
+      });
+
+      const overridden = extension.override({
+        factory({ originalFactory }, { text }) {
+          return {
+            element: (
+              <div>
+                {originalFactory().element}
+                <h3>{text}</h3>
+              </div>
+            ),
+          };
+        },
+      });
+
+      const { container } = createExtensionTester(overridden).render();
+      expect(container.querySelector('h2')).toHaveTextContent('Hello, world!');
+      expect(container.querySelector('h3')).toHaveTextContent('Hello, world!');
+    });
+  });
+
+  it('should allow calling the kind factory if another factory is not defined in the instance', () => {
+    const TestExtension = createExtensionKind({
+      kind: 'test-extension',
+      attachTo: { id: 'test', input: 'default' },
+      output: {
+        element: coreExtensionData.reactElement,
+      },
+      factory(_, options: { text: string }) {
+        return {
+          element: <h1>{options.text}</h1>,
+        };
+      },
+    });
+
+    const extension = TestExtension.new({
+      name: 'my-extension',
+      options: {
+        text: 'Hello, world!',
+      },
+    });
+
+    const overridden = extension.override({
+      factory({ originalFactory }, { text }) {
+        return {
+          element: (
+            <div>
+              {originalFactory().element}
+              <h3>{text}</h3>
+            </div>
+          ),
+        };
+      },
+    });
+
+    const { container } = createExtensionTester(overridden).render();
+    expect(container.querySelector('h1')).toHaveTextContent('Hello, world!');
+    expect(container.querySelector('h3')).toHaveTextContent('Hello, world!');
+  });
 });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
index 353fb8ab70..9813c9e50c 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -13,6 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
+
 import { AppNode } from '../apis';
 import { PortableSchema } from '../schema';
 import { Expand } from '../types';
@@ -52,6 +53,76 @@ export interface CreateExtensionKindOptions<
   ): Expand<ExtensionDataValues<TOutput>>;
 }
 
+/**
+ * @public
+ */
+export interface CreateExtensionKindInstanceOptions<
+  TOptions,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  namespace?: string;
+  name?: string;
+  attachTo?: { id: string; input: string };
+  disabled?: boolean;
+  inputs?: TInputs;
+  output?: TOutput;
+  configSchema?: PortableSchema<TConfig>;
+  options: TOptions;
+  factory?(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+      originalFactory(
+        context?: {
+          node?: AppNode;
+          config?: TConfig;
+          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+        },
+        options?: TOptions,
+      ): Expand<ExtensionDataValues<TOutput>>;
+    },
+    options: TOptions,
+  ): Expand<ExtensionDataValues<TOutput>>;
+}
+
+/**
+ * @public
+ */
+export interface CreateExtensionOverrideKindInstanceOptions<
+  TOptions,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  namespace?: string;
+  name?: string;
+  attachTo?: { id: string; input: string };
+  disabled?: boolean;
+  inputs?: TInputs;
+  output?: TOutput;
+  configSchema?: PortableSchema<TConfig>;
+  options?: TOptions;
+  factory?(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+      originalFactory(
+        context?: {
+          node?: AppNode;
+          config?: TConfig;
+          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+        },
+        options?: TOptions,
+      ): Expand<ExtensionDataValues<TOutput>>;
+    },
+    options: TOptions,
+  ): Expand<ExtensionDataValues<TOutput>>;
+}
+
 /**
  * TODO: should we export an interface instead of a concrete class?
  * @public
@@ -74,7 +145,7 @@ export class ExtensionKind<
   }
 
   private constructor(
-    private readonly options: CreateExtensionKindOptions<
+    private readonly kindProperties: CreateExtensionKindOptions<
       TOptions,
       TInputs,
       TOutput,
@@ -82,49 +153,41 @@ export class ExtensionKind<
     >,
   ) {}
 
-  public new(args: {
-    namespace?: string;
-    name?: string;
-    attachTo?: { id: string; input: string };
-    disabled?: boolean;
-    inputs?: TInputs;
-    output?: TOutput;
-    configSchema?: PortableSchema<TConfig>;
-    options: TOptions;
-    factory?(
-      context: {
-        node: AppNode;
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        orignalFactory(
-          context?: {
-            node?: AppNode;
-            config?: TConfig;
-            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-          },
-          options?: TOptions,
-        ): Expand<ExtensionDataValues<TOutput>>;
-      },
-      options: TOptions,
-    ): Expand<ExtensionDataValues<TOutput>>;
-  }): ExtensionDefinition<TConfig, TInputs> {
-    return createExtension({
-      kind: this.options.kind,
-      namespace: args.namespace ?? this.options.namespace,
-      name: args.name ?? this.options.name,
-      attachTo: args.attachTo ?? this.options.attachTo,
-      disabled: args.disabled ?? this.options.disabled,
-      inputs: args.inputs ?? this.options.inputs,
-      output: args.output ?? this.options.output,
-      configSchema: args.configSchema ?? this.options.configSchema, // TODO: some config merging or smth
+  public new(
+    instanceProperties: CreateExtensionKindInstanceOptions<
+      TOptions,
+      TInputs,
+      TOutput,
+      TConfig
+    >,
+  ): ExtensionDefinition<TConfig> & {
+    override: (
+      overrides: CreateExtensionOverrideKindInstanceOptions<
+        TOptions,
+        TInputs,
+        TOutput,
+        TConfig
+      >,
+    ) => ExtensionDefinition<TConfig>;
+  } {
+    const extension = createExtension({
+      kind: this.kindProperties.kind,
+      namespace: instanceProperties.namespace ?? this.kindProperties.namespace,
+      name: instanceProperties.name ?? this.kindProperties.name,
+      attachTo: instanceProperties.attachTo ?? this.kindProperties.attachTo,
+      disabled: instanceProperties.disabled ?? this.kindProperties.disabled,
+      inputs: instanceProperties.inputs ?? this.kindProperties.inputs,
+      output: instanceProperties.output ?? this.kindProperties.output,
+      configSchema:
+        instanceProperties.configSchema ?? this.kindProperties.configSchema, // TODO: some config merging or smth
       factory: ({ node, config, inputs }) => {
-        if (args.factory) {
-          return args.factory(
+        if (instanceProperties.factory) {
+          return instanceProperties.factory(
             {
               node,
               config,
               inputs,
-              orignalFactory: (
+              originalFactory: (
                 innerContext?: {
                   node?: AppNode;
                   config?: TConfig;
@@ -132,29 +195,123 @@ export class ExtensionKind<
                 },
                 innerOptions?: TOptions,
               ) =>
-                this.options.factory(
+                this.kindProperties.factory(
                   {
                     node: innerContext?.node ?? node,
                     config: innerContext?.config ?? config,
                     inputs: innerContext?.inputs ?? inputs,
                   },
-                  innerOptions ?? args.options,
+                  innerOptions ?? instanceProperties.options,
                 ),
             },
-            args.options,
+            instanceProperties.options,
           );
         }
 
-        return this.options.factory(
+        return this.kindProperties.factory(
           {
             node,
             config,
             inputs,
           },
-          args.options,
+          instanceProperties.options,
         );
       },
     });
+
+    return {
+      ...extension,
+      override: overrides => {
+        return createExtension({
+          kind: this.kindProperties.kind,
+          namespace:
+            overrides.namespace ??
+            instanceProperties.namespace ??
+            this.kindProperties.namespace,
+          name:
+            overrides.name ??
+            instanceProperties.name ??
+            this.kindProperties.name,
+          attachTo:
+            overrides.attachTo ??
+            instanceProperties.attachTo ??
+            this.kindProperties.attachTo,
+          disabled:
+            overrides.disabled ??
+            instanceProperties.disabled ??
+            this.kindProperties.disabled,
+          inputs:
+            overrides.inputs ??
+            instanceProperties.inputs ??
+            this.kindProperties.inputs,
+          output:
+            overrides.output ??
+            instanceProperties.output ??
+            this.kindProperties.output,
+          configSchema:
+            overrides.configSchema ??
+            instanceProperties.configSchema ??
+            this.kindProperties.configSchema, // TODO: some config merging or smth
+          factory: ({ node, config, inputs }) => {
+            if (overrides.factory) {
+              return overrides.factory(
+                {
+                  node,
+                  config,
+                  inputs,
+                  originalFactory: (
+                    innerContext?: {
+                      node?: AppNode;
+                      config?: TConfig;
+                      inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+                    },
+                    innerOptions?: TOptions,
+                  ) =>
+                    instanceProperties.factory?.(
+                      {
+                        node: innerContext?.node ?? node,
+                        config: innerContext?.config ?? config,
+                        inputs: innerContext?.inputs ?? inputs,
+                        originalFactory: this.kindProperties.factory,
+                      },
+                      innerOptions ?? instanceProperties.options,
+                    ) ??
+                    this.kindProperties.factory(
+                      {
+                        node,
+                        config,
+                        inputs,
+                      },
+                      innerOptions ?? instanceProperties.options,
+                    ),
+                },
+                instanceProperties.options,
+              );
+            }
+
+            return (
+              instanceProperties.factory?.(
+                {
+                  node,
+                  config,
+                  inputs,
+                  originalFactory: this.kindProperties.factory,
+                },
+                instanceProperties.options,
+              ) ??
+              this.kindProperties.factory(
+                {
+                  node,
+                  config,
+                  inputs,
+                },
+                instanceProperties.options,
+              )
+            );
+          },
+        });
+      },
+    };
   }
 }
 
diff --git a/packages/frontend-plugin-api/src/wiring/index.ts b/packages/frontend-plugin-api/src/wiring/index.ts
index 8fe9dc3a54..a312c0f06f 100644
--- a/packages/frontend-plugin-api/src/wiring/index.ts
+++ b/packages/frontend-plugin-api/src/wiring/index.ts
@@ -49,7 +49,9 @@ export {
   type FrontendFeature,
 } from './types';
 export {
-  type CreateExtensionKindOptions as ExtensionKindOptions,
+  type CreateExtensionKindOptions,
+  type CreateExtensionKindInstanceOptions,
+  type CreateExtensionOverrideKindInstanceOptions,
   ExtensionKind,
   createExtensionKind,
 } from './createExtensionKind';

From 6b6cbdaac5cf05702210e9c24ccb4272c3ba3e88 Mon Sep 17 00:00:00 2001
From: Ben Lambert <ben@blam.sh>
Date: Thu, 18 Jul 2024 13:07:02 +0200
Subject: [PATCH 10/14] Revert "NFE: Make it possible to override existing
 extension instances"

Signed-off-by: blam <ben@blam.sh>
---
 packages/frontend-plugin-api/api-report.md    | 214 +++++----------
 .../src/wiring/createExtension.ts             |   4 +-
 .../src/wiring/createExtensionKind.test.tsx   | 164 ------------
 .../src/wiring/createExtensionKind.ts         | 245 ++++--------------
 .../frontend-plugin-api/src/wiring/index.ts   |   4 +-
 5 files changed, 115 insertions(+), 516 deletions(-)

diff --git a/packages/frontend-plugin-api/api-report.md b/packages/frontend-plugin-api/api-report.md
index 6a04d04cd6..48718f5375 100644
--- a/packages/frontend-plugin-api/api-report.md
+++ b/packages/frontend-plugin-api/api-report.md
@@ -529,91 +529,9 @@ export function createExtensionKind<
   TOutput extends AnyExtensionDataMap,
   TConfig,
 >(
-  options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+  options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
 ): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
 
-// @public (undocumented)
-export interface CreateExtensionKindInstanceOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  // (undocumented)
-  attachTo?: {
-    id: string;
-    input: string;
-  };
-  // (undocumented)
-  configSchema?: PortableSchema<TConfig>;
-  // (undocumented)
-  disabled?: boolean;
-  // (undocumented)
-  factory?(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-      originalFactory(
-        context?: {
-          node?: AppNode;
-          config?: TConfig;
-          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-        },
-        options?: TOptions,
-      ): Expand<ExtensionDataValues<TOutput>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-  // (undocumented)
-  inputs?: TInputs;
-  // (undocumented)
-  name?: string;
-  // (undocumented)
-  namespace?: string;
-  // (undocumented)
-  options: TOptions;
-  // (undocumented)
-  output?: TOutput;
-}
-
-// @public (undocumented)
-export interface CreateExtensionKindOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  // (undocumented)
-  attachTo: {
-    id: string;
-    input: string;
-  };
-  // (undocumented)
-  configSchema?: PortableSchema<TConfig>;
-  // (undocumented)
-  disabled?: boolean;
-  // (undocumented)
-  factory(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-  // (undocumented)
-  inputs?: TInputs;
-  // (undocumented)
-  kind: string;
-  // (undocumented)
-  name?: string;
-  // (undocumented)
-  namespace?: string;
-  // (undocumented)
-  output: TOutput;
-}
-
 // @public (undocumented)
 export interface CreateExtensionOptions<
   TOutput extends AnyExtensionDataMap,
@@ -630,7 +548,7 @@ export interface CreateExtensionOptions<
   // (undocumented)
   disabled?: boolean;
   // (undocumented)
-  factory(options: {
+  factory(context: {
     node: AppNode;
     config: TConfig;
     inputs: Expand<ResolvedExtensionInputs<TInputs>>;
@@ -647,51 +565,6 @@ export interface CreateExtensionOptions<
   output: TOutput;
 }
 
-// @public (undocumented)
-export interface CreateExtensionOverrideKindInstanceOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  // (undocumented)
-  attachTo?: {
-    id: string;
-    input: string;
-  };
-  // (undocumented)
-  configSchema?: PortableSchema<TConfig>;
-  // (undocumented)
-  disabled?: boolean;
-  // (undocumented)
-  factory?(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-      originalFactory(
-        context?: {
-          node?: AppNode;
-          config?: TConfig;
-          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-        },
-        options?: TOptions,
-      ): Expand<ExtensionDataValues<TOutput>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-  // (undocumented)
-  inputs?: TInputs;
-  // (undocumented)
-  name?: string;
-  // (undocumented)
-  namespace?: string;
-  // (undocumented)
-  options?: TOptions;
-  // (undocumented)
-  output?: TOutput;
-}
-
 // @public (undocumented)
 export function createExtensionOverrides(
   options: ExtensionOverridesOptions,
@@ -1064,26 +937,75 @@ export class ExtensionKind<
     TOutput extends AnyExtensionDataMap,
     TConfig,
   >(
-    options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
+    options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
   ): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
   // (undocumented)
-  new(
-    instanceProperties: CreateExtensionKindInstanceOptions<
-      TOptions,
-      TInputs,
-      TOutput,
-      TConfig
-    >,
-  ): ExtensionDefinition<TConfig> & {
-    override: (
-      overrides: CreateExtensionOverrideKindInstanceOptions<
-        TOptions,
-        TInputs,
-        TOutput,
-        TConfig
-      >,
-    ) => ExtensionDefinition<TConfig>;
+  new(args: {
+    namespace?: string;
+    name?: string;
+    attachTo?: {
+      id: string;
+      input: string;
+    };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output?: TOutput;
+    configSchema?: PortableSchema<TConfig>;
+    options: TOptions;
+    factory?(
+      context: {
+        node: AppNode;
+        config: TConfig;
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        orignalFactory(
+          context?: {
+            node?: AppNode;
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+          },
+          options?: TOptions,
+        ): Expand<ExtensionDataValues<TOutput>>;
+      },
+      options: TOptions,
+    ): Expand<ExtensionDataValues<TOutput>>;
+  }): ExtensionDefinition<TConfig>;
+}
+
+// @public (undocumented)
+export interface ExtensionKindOptions<
+  TOptions,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  attachTo: {
+    id: string;
+    input: string;
   };
+  // (undocumented)
+  configSchema?: PortableSchema<TConfig>;
+  // (undocumented)
+  disabled?: boolean;
+  // (undocumented)
+  factory(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    },
+    options: TOptions,
+  ): Expand<ExtensionDataValues<TOutput>>;
+  // (undocumented)
+  inputs?: TInputs;
+  // (undocumented)
+  kind: string;
+  // (undocumented)
+  name?: string;
+  // (undocumented)
+  namespace?: string;
+  // (undocumented)
+  output: TOutput;
 }
 
 // @public (undocumented)
diff --git a/packages/frontend-plugin-api/src/wiring/createExtension.ts b/packages/frontend-plugin-api/src/wiring/createExtension.ts
index be76fbc069..28dc6a4e29 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtension.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtension.ts
@@ -91,7 +91,7 @@ export interface CreateExtensionOptions<
   inputs?: TInputs;
   output: TOutput;
   configSchema?: PortableSchema<TConfig>;
-  factory(options: {
+  factory(context: {
     node: AppNode;
     config: TConfig;
     inputs: Expand<ResolvedExtensionInputs<TInputs>>;
@@ -115,7 +115,7 @@ export interface InternalExtensionDefinition<TConfig>
   readonly version: 'v1';
   readonly inputs: AnyExtensionInputMap;
   readonly output: AnyExtensionDataMap;
-  factory(options: {
+  factory(context: {
     node: AppNode;
     config: TConfig;
     inputs: ResolvedExtensionInputs<any>;
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
index 30c3e6ca44..3bdcd3a7cc 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
@@ -64,7 +64,6 @@ describe('createExtensionKind', () => {
       },
       factory: expect.any(Function),
       toString: expect.any(Function),
-      override: expect.any(Function),
       version: 'v1',
     });
 
@@ -103,167 +102,4 @@ describe('createExtensionKind', () => {
     const { container } = createExtensionTester(extension).render();
     expect(container.querySelector('h2')).toHaveTextContent('Hello, world!');
   });
-
-  it('should allow calling of the default value from override', () => {
-    const TestExtension = createExtensionKind({
-      kind: 'test-extension',
-      attachTo: { id: 'test', input: 'default' },
-      output: {
-        element: coreExtensionData.reactElement,
-      },
-      factory(_, options: { text: string }) {
-        return {
-          element: <h1>{options.text}</h1>,
-        };
-      },
-    });
-
-    const extension = TestExtension.new({
-      name: 'my-extension',
-      options: {
-        text: 'Hello, world!',
-      },
-      factory({ originalFactory }, options: { text: string }) {
-        const { element } = originalFactory();
-        return {
-          element: (
-            <h2>
-              {options.text}
-              {element}
-            </h2>
-          ),
-        };
-      },
-    });
-
-    expect(extension).toBeDefined();
-
-    const { container } = createExtensionTester(extension).render();
-
-    expect(container.querySelector('h2 h1')).toHaveTextContent('Hello, world!');
-  });
-
-  it('should allow overriding options of the default value from override', () => {
-    const TestExtension = createExtensionKind({
-      kind: 'test-extension',
-      attachTo: { id: 'test', input: 'default' },
-      output: {
-        element: coreExtensionData.reactElement,
-      },
-      factory(_, options: { text: string }) {
-        return {
-          element: <h1>{options.text}</h1>,
-        };
-      },
-    });
-
-    const extension = TestExtension.new({
-      name: 'my-extension',
-      options: {
-        text: 'Hello, world!',
-      },
-      factory({ originalFactory }, options: { text: string }) {
-        const { element } = originalFactory(undefined, { text: 'nothing!' });
-        return {
-          element: (
-            <h2>
-              {options.text}
-              {element}
-            </h2>
-          ),
-        };
-      },
-    });
-
-    expect(extension).toBeDefined();
-
-    const { container } = createExtensionTester(extension).render();
-
-    expect(container.querySelector('h2 h1')).toHaveTextContent('nothing!');
-  });
-
-  describe('override', () => {
-    it('should allow overriding of the default factory', () => {
-      const TestExtension = createExtensionKind({
-        kind: 'test-extension',
-        attachTo: { id: 'test', input: 'default' },
-        output: {
-          element: coreExtensionData.reactElement,
-        },
-        factory(_, options: { text: string }) {
-          return {
-            element: <h1>{options.text}</h1>,
-          };
-        },
-      });
-
-      const extension = TestExtension.new({
-        name: 'my-extension',
-        options: {
-          text: 'Hello, world!',
-        },
-        factory(_, options: { text: string }) {
-          return {
-            element: <h2>{options.text}</h2>,
-          };
-        },
-      });
-
-      const overridden = extension.override({
-        factory({ originalFactory }, { text }) {
-          return {
-            element: (
-              <div>
-                {originalFactory().element}
-                <h3>{text}</h3>
-              </div>
-            ),
-          };
-        },
-      });
-
-      const { container } = createExtensionTester(overridden).render();
-      expect(container.querySelector('h2')).toHaveTextContent('Hello, world!');
-      expect(container.querySelector('h3')).toHaveTextContent('Hello, world!');
-    });
-  });
-
-  it('should allow calling the kind factory if another factory is not defined in the instance', () => {
-    const TestExtension = createExtensionKind({
-      kind: 'test-extension',
-      attachTo: { id: 'test', input: 'default' },
-      output: {
-        element: coreExtensionData.reactElement,
-      },
-      factory(_, options: { text: string }) {
-        return {
-          element: <h1>{options.text}</h1>,
-        };
-      },
-    });
-
-    const extension = TestExtension.new({
-      name: 'my-extension',
-      options: {
-        text: 'Hello, world!',
-      },
-    });
-
-    const overridden = extension.override({
-      factory({ originalFactory }, { text }) {
-        return {
-          element: (
-            <div>
-              {originalFactory().element}
-              <h3>{text}</h3>
-            </div>
-          ),
-        };
-      },
-    });
-
-    const { container } = createExtensionTester(overridden).render();
-    expect(container.querySelector('h1')).toHaveTextContent('Hello, world!');
-    expect(container.querySelector('h3')).toHaveTextContent('Hello, world!');
-  });
 });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
index 9813c9e50c..52bf711822 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -21,7 +21,6 @@ import {
   AnyExtensionDataMap,
   AnyExtensionInputMap,
   ExtensionDataValues,
-  ExtensionDefinition,
   ResolvedExtensionInputs,
   createExtension,
 } from './createExtension';
@@ -53,76 +52,6 @@ export interface CreateExtensionKindOptions<
   ): Expand<ExtensionDataValues<TOutput>>;
 }
 
-/**
- * @public
- */
-export interface CreateExtensionKindInstanceOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  namespace?: string;
-  name?: string;
-  attachTo?: { id: string; input: string };
-  disabled?: boolean;
-  inputs?: TInputs;
-  output?: TOutput;
-  configSchema?: PortableSchema<TConfig>;
-  options: TOptions;
-  factory?(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-      originalFactory(
-        context?: {
-          node?: AppNode;
-          config?: TConfig;
-          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-        },
-        options?: TOptions,
-      ): Expand<ExtensionDataValues<TOutput>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-}
-
-/**
- * @public
- */
-export interface CreateExtensionOverrideKindInstanceOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  namespace?: string;
-  name?: string;
-  attachTo?: { id: string; input: string };
-  disabled?: boolean;
-  inputs?: TInputs;
-  output?: TOutput;
-  configSchema?: PortableSchema<TConfig>;
-  options?: TOptions;
-  factory?(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-      originalFactory(
-        context?: {
-          node?: AppNode;
-          config?: TConfig;
-          inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-        },
-        options?: TOptions,
-      ): Expand<ExtensionDataValues<TOutput>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-}
-
 /**
  * TODO: should we export an interface instead of a concrete class?
  * @public
@@ -145,7 +74,7 @@ export class ExtensionKind<
   }
 
   private constructor(
-    private readonly kindProperties: CreateExtensionKindOptions<
+    private readonly options: CreateExtensionKindOptions<
       TOptions,
       TInputs,
       TOutput,
@@ -153,41 +82,49 @@ export class ExtensionKind<
     >,
   ) {}
 
-  public new(
-    instanceProperties: CreateExtensionKindInstanceOptions<
-      TOptions,
-      TInputs,
-      TOutput,
-      TConfig
-    >,
-  ): ExtensionDefinition<TConfig> & {
-    override: (
-      overrides: CreateExtensionOverrideKindInstanceOptions<
-        TOptions,
-        TInputs,
-        TOutput,
-        TConfig
-      >,
-    ) => ExtensionDefinition<TConfig>;
-  } {
-    const extension = createExtension({
-      kind: this.kindProperties.kind,
-      namespace: instanceProperties.namespace ?? this.kindProperties.namespace,
-      name: instanceProperties.name ?? this.kindProperties.name,
-      attachTo: instanceProperties.attachTo ?? this.kindProperties.attachTo,
-      disabled: instanceProperties.disabled ?? this.kindProperties.disabled,
-      inputs: instanceProperties.inputs ?? this.kindProperties.inputs,
-      output: instanceProperties.output ?? this.kindProperties.output,
-      configSchema:
-        instanceProperties.configSchema ?? this.kindProperties.configSchema, // TODO: some config merging or smth
+  public new(args: {
+    namespace?: string;
+    name?: string;
+    attachTo?: { id: string; input: string };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output?: TOutput;
+    configSchema?: PortableSchema<TConfig>;
+    options: TOptions;
+    factory?(
+      context: {
+        node: AppNode;
+        config: TConfig;
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        orignalFactory(
+          context?: {
+            node?: AppNode;
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+          },
+          options?: TOptions,
+        ): Expand<ExtensionDataValues<TOutput>>;
+      },
+      options: TOptions,
+    ): Expand<ExtensionDataValues<TOutput>>;
+  }) {
+    return createExtension({
+      kind: this.options.kind,
+      namespace: args.namespace ?? this.options.namespace,
+      name: args.name ?? this.options.name,
+      attachTo: args.attachTo ?? this.options.attachTo,
+      disabled: args.disabled ?? this.options.disabled,
+      inputs: args.inputs ?? this.options.inputs,
+      output: args.output ?? this.options.output,
+      configSchema: args.configSchema ?? this.options.configSchema, // TODO: some config merging or smth
       factory: ({ node, config, inputs }) => {
-        if (instanceProperties.factory) {
-          return instanceProperties.factory(
+        if (args.factory) {
+          return args.factory(
             {
               node,
               config,
               inputs,
-              originalFactory: (
+              orignalFactory: (
                 innerContext?: {
                   node?: AppNode;
                   config?: TConfig;
@@ -195,123 +132,29 @@ export class ExtensionKind<
                 },
                 innerOptions?: TOptions,
               ) =>
-                this.kindProperties.factory(
+                this.options.factory(
                   {
                     node: innerContext?.node ?? node,
                     config: innerContext?.config ?? config,
                     inputs: innerContext?.inputs ?? inputs,
                   },
-                  innerOptions ?? instanceProperties.options,
+                  innerOptions ?? args.options,
                 ),
             },
-            instanceProperties.options,
+            args.options,
           );
         }
 
-        return this.kindProperties.factory(
+        return this.options.factory(
           {
             node,
             config,
             inputs,
           },
-          instanceProperties.options,
+          args.options,
         );
       },
     });
-
-    return {
-      ...extension,
-      override: overrides => {
-        return createExtension({
-          kind: this.kindProperties.kind,
-          namespace:
-            overrides.namespace ??
-            instanceProperties.namespace ??
-            this.kindProperties.namespace,
-          name:
-            overrides.name ??
-            instanceProperties.name ??
-            this.kindProperties.name,
-          attachTo:
-            overrides.attachTo ??
-            instanceProperties.attachTo ??
-            this.kindProperties.attachTo,
-          disabled:
-            overrides.disabled ??
-            instanceProperties.disabled ??
-            this.kindProperties.disabled,
-          inputs:
-            overrides.inputs ??
-            instanceProperties.inputs ??
-            this.kindProperties.inputs,
-          output:
-            overrides.output ??
-            instanceProperties.output ??
-            this.kindProperties.output,
-          configSchema:
-            overrides.configSchema ??
-            instanceProperties.configSchema ??
-            this.kindProperties.configSchema, // TODO: some config merging or smth
-          factory: ({ node, config, inputs }) => {
-            if (overrides.factory) {
-              return overrides.factory(
-                {
-                  node,
-                  config,
-                  inputs,
-                  originalFactory: (
-                    innerContext?: {
-                      node?: AppNode;
-                      config?: TConfig;
-                      inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-                    },
-                    innerOptions?: TOptions,
-                  ) =>
-                    instanceProperties.factory?.(
-                      {
-                        node: innerContext?.node ?? node,
-                        config: innerContext?.config ?? config,
-                        inputs: innerContext?.inputs ?? inputs,
-                        originalFactory: this.kindProperties.factory,
-                      },
-                      innerOptions ?? instanceProperties.options,
-                    ) ??
-                    this.kindProperties.factory(
-                      {
-                        node,
-                        config,
-                        inputs,
-                      },
-                      innerOptions ?? instanceProperties.options,
-                    ),
-                },
-                instanceProperties.options,
-              );
-            }
-
-            return (
-              instanceProperties.factory?.(
-                {
-                  node,
-                  config,
-                  inputs,
-                  originalFactory: this.kindProperties.factory,
-                },
-                instanceProperties.options,
-              ) ??
-              this.kindProperties.factory(
-                {
-                  node,
-                  config,
-                  inputs,
-                },
-                instanceProperties.options,
-              )
-            );
-          },
-        });
-      },
-    };
   }
 }
 
diff --git a/packages/frontend-plugin-api/src/wiring/index.ts b/packages/frontend-plugin-api/src/wiring/index.ts
index a312c0f06f..8fe9dc3a54 100644
--- a/packages/frontend-plugin-api/src/wiring/index.ts
+++ b/packages/frontend-plugin-api/src/wiring/index.ts
@@ -49,9 +49,7 @@ export {
   type FrontendFeature,
 } from './types';
 export {
-  type CreateExtensionKindOptions,
-  type CreateExtensionKindInstanceOptions,
-  type CreateExtensionOverrideKindInstanceOptions,
+  type CreateExtensionKindOptions as ExtensionKindOptions,
   ExtensionKind,
   createExtensionKind,
 } from './createExtensionKind';

From b20c067c61abcfff3f158b7f4b6c5857dfbf347a Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Thu, 18 Jul 2024 13:27:09 +0200
Subject: [PATCH 11/14] chore: fixing some code review comments

Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md                  |   8 +-
 .../src/wiring/createExtensionKind.ts         | 108 +++++++++++-------
 2 files changed, 70 insertions(+), 46 deletions(-)

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
index 9bd835d371..5a865395c0 100644
--- a/.changeset/dry-squids-tap.md
+++ b/.changeset/dry-squids-tap.md
@@ -14,17 +14,17 @@ const TestExtensionKind = createExtensionKind({
   output: {
     element: coreExtensionData.reactElement,
   },
-  factory(_, options: { text: string }) {
+  factory(_, params: { text: string }) {
     return {
-      element: <h1>{options.text}</h1>,
+      element: <h1>{params.text}</h1>,
     };
   },
 });
 
 // create an instance of the extension kind with props
-const testExtension = TestExtensionKind.new({
+const testExtension = TestExtensionKind.create({
   name: 'foo',
-  options: {
+  params: {
     text: 'Hello World',
   },
 });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
index 52bf711822..1212365712 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
@@ -21,6 +21,7 @@ import {
   AnyExtensionDataMap,
   AnyExtensionInputMap,
   ExtensionDataValues,
+  ExtensionDefinition,
   ResolvedExtensionInputs,
   createExtension,
 } from './createExtension';
@@ -29,14 +30,13 @@ import {
  * @public
  */
 export interface CreateExtensionKindOptions<
-  TOptions,
+  TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 > {
   kind: string;
   namespace?: string;
-  name?: string;
   attachTo: { id: string; input: string };
   disabled?: boolean;
   inputs?: TInputs;
@@ -48,41 +48,20 @@ export interface CreateExtensionKindOptions<
       config: TConfig;
       inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     },
-    options: TOptions,
+    params: TParams,
   ): Expand<ExtensionDataValues<TOutput>>;
 }
 
 /**
- * TODO: should we export an interface instead of a concrete class?
  * @public
  */
-export class ExtensionKind<
-  TOptions,
+export interface ExtensionKind<
+  TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 > {
-  static create<
-    TOptions,
-    TInputs extends AnyExtensionInputMap,
-    TOutput extends AnyExtensionDataMap,
-    TConfig,
-  >(
-    options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
-  ): ExtensionKind<TOptions, TInputs, TOutput, TConfig> {
-    return new ExtensionKind(options);
-  }
-
-  private constructor(
-    private readonly options: CreateExtensionKindOptions<
-      TOptions,
-      TInputs,
-      TOutput,
-      TConfig
-    >,
-  ) {}
-
-  public new(args: {
+  create(args: {
     namespace?: string;
     name?: string;
     attachTo?: { id: string; input: string };
@@ -90,7 +69,7 @@ export class ExtensionKind<
     inputs?: TInputs;
     output?: TOutput;
     configSchema?: PortableSchema<TConfig>;
-    options: TOptions;
+    params: TParams;
     factory?(
       context: {
         node: AppNode;
@@ -98,20 +77,64 @@ export class ExtensionKind<
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
           context?: {
-            node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
-          options?: TOptions,
+          params?: TParams,
         ): Expand<ExtensionDataValues<TOutput>>;
       },
-      options: TOptions,
+      params: TParams,
     ): Expand<ExtensionDataValues<TOutput>>;
-  }) {
+  }): ExtensionDefinition<TConfig>;
+}
+
+/**
+ * @internal
+ */
+class ExtensionKindImpl<
+  TParams,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  constructor(
+    private readonly options: CreateExtensionKindOptions<
+      TParams,
+      TInputs,
+      TOutput,
+      TConfig
+    >,
+  ) {}
+
+  public create(args: {
+    namespace?: string;
+    name?: string;
+    attachTo?: { id: string; input: string };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output?: TOutput;
+    configSchema?: PortableSchema<TConfig>;
+    params: TParams;
+    factory?(
+      context: {
+        node: AppNode;
+        config: TConfig;
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        orignalFactory(
+          context?: {
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+          },
+          params?: TParams,
+        ): Expand<ExtensionDataValues<TOutput>>;
+      },
+      params: TParams,
+    ): Expand<ExtensionDataValues<TOutput>>;
+  }): ExtensionDefinition<TConfig> {
     return createExtension({
       kind: this.options.kind,
       namespace: args.namespace ?? this.options.namespace,
-      name: args.name ?? this.options.name,
+      name: args.name,
       attachTo: args.attachTo ?? this.options.attachTo,
       disabled: args.disabled ?? this.options.disabled,
       inputs: args.inputs ?? this.options.inputs,
@@ -126,22 +149,21 @@ export class ExtensionKind<
               inputs,
               orignalFactory: (
                 innerContext?: {
-                  node?: AppNode;
                   config?: TConfig;
                   inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
                 },
-                innerOptions?: TOptions,
+                innerParams?: TParams,
               ) =>
                 this.options.factory(
                   {
-                    node: innerContext?.node ?? node,
+                    node,
                     config: innerContext?.config ?? config,
                     inputs: innerContext?.inputs ?? inputs,
                   },
-                  innerOptions ?? args.options,
+                  innerParams ?? args.params,
                 ),
             },
-            args.options,
+            args.params,
           );
         }
 
@@ -151,7 +173,7 @@ export class ExtensionKind<
             config,
             inputs,
           },
-          args.options,
+          args.params,
         );
       },
     });
@@ -165,10 +187,12 @@ export class ExtensionKind<
  * @public
  */
 export function createExtensionKind<
-  TOptions,
+  TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
->(options: CreateExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>) {
-  return ExtensionKind.create(options);
+>(
+  options: CreateExtensionKindOptions<TParams, TInputs, TOutput, TConfig>,
+): ExtensionKind<TParams, TInputs, TOutput, TConfig> {
+  return new ExtensionKindImpl(options);
 }

From 4e42e5112cd692ab40696b3970e016cba94b4456 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Thu, 18 Jul 2024 13:50:26 +0200
Subject: [PATCH 12/14] chore: smaller renames and code review

Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md                  |  6 ++--
 .../architecture/08-naming-patterns.md        | 20 ++++++-------
 ....tsx => createExtensionBlueprint.test.tsx} | 30 +++++++++----------
 ...ionKind.ts => createExtensionBlueprint.ts} | 22 +++++++-------
 .../frontend-plugin-api/src/wiring/index.ts   |  8 ++---
 5 files changed, 43 insertions(+), 43 deletions(-)
 rename packages/frontend-plugin-api/src/wiring/{createExtensionKind.test.tsx => createExtensionBlueprint.test.tsx} (77%)
 rename packages/frontend-plugin-api/src/wiring/{createExtensionKind.ts => createExtensionBlueprint.ts} (90%)

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
index 5a865395c0..879ecb5d14 100644
--- a/.changeset/dry-squids-tap.md
+++ b/.changeset/dry-squids-tap.md
@@ -8,8 +8,8 @@ This allows the creation of extension with the following pattern:
 
 ```tsx
 // create the extension kind
-const TestExtensionKind = createExtensionKind({
-  kind: 'test-extension',
+const EntityCardBlueprint = createExtensionBlueprint({
+  kind: 'entity-card',
   attachTo: { id: 'test', input: 'default' },
   output: {
     element: coreExtensionData.reactElement,
@@ -22,7 +22,7 @@ const TestExtensionKind = createExtensionKind({
 });
 
 // create an instance of the extension kind with props
-const testExtension = TestExtensionKind.create({
+const testExtension = EntityCardBlueprint.make({
   name: 'foo',
   params: {
     text: 'Hello World',
diff --git a/docs/frontend-system/architecture/08-naming-patterns.md b/docs/frontend-system/architecture/08-naming-patterns.md
index 0916d9fd51..a17525f3ce 100644
--- a/docs/frontend-system/architecture/08-naming-patterns.md
+++ b/docs/frontend-system/architecture/08-naming-patterns.md
@@ -38,33 +38,31 @@ Note that while we use this naming pattern for the plugin instance this is only
 
 | Description | Pattern                         | Examples                                                            |
 | ----------- | ------------------------------- | ------------------------------------------------------------------- |
-| Creator     | `create<Kind>Extension`         | `createPageExtension`, `createEntityCardExtension`                  |
+| Blueprint   | `<Kind>Blueprint`               | `PageBlueprint`, `EntityCardBlueprint`                              |
 | ID          | `[<kind>:]<namespace>[/<name>]` | `'core.nav'`, `'page:user-settings'`, `'entity-card:catalog/about'` |
 | Symbol      | `<namespace>[<Name>][<Kind>]`   | `coreNav`, `userSettingsPage`, `catalogAboutEntityCard`             |
 
-When you create a new extension you never provide the ID directly. Instead, you indirectly or directly provide the kind, namespace, and name parts that make up the ID. The kind is always provided by the extension creator function used to create the extension, the only exception is if you use `createExtension` directly. Any extension that is provided by a plugin will by default have its namespace set to the plugin ID, so you generally only need to provide an explicit namespace if you want to override an existing extension. The name is also optional, and primarily used to distinguish between multiple extensions of the same kind and namespace. If a plugin doesn't need to distinguish between different extensions of the same kind, the name can be omitted.
+When you create a new extension you never provide the ID directly. Instead, you indirectly or directly provide the kind, namespace, and name parts that make up the ID. The kind is always provided by the blueprint creator, the only exception is if you use `createExtension` directly. Any extension that is provided by a plugin will by default have its namespace set to the plugin ID, so you generally only need to provide an explicit namespace if you want to override an existing extension. The name is also optional, and primarily used to distinguish between multiple extensions of the same kind and namespace. If a plugin doesn't need to distinguish between different extensions of the same kind, the name can be omitted.
 
 Example:
 
 ```ts
-// This is an extension creator that is used to create an extension of the 'page' kind.
-export function createPageExtension(options) {
-  return createExtension({
-    kind: 'page', // Kinds are kebab-case
-    // ...options
-  });
-}
+// This is an extension blueprint that is used to create an extension of the 'page' kind.
+export const PageBlueprint = createExtensionBlueprint({
+  kind: 'page',
+  // ...
+});
 
 // The namespace is inferred from the plugin ID, in this case 'catalog'
 // The final ID for this extension will be 'page:catalog/entity'
-const catalogEntityPage = createPageExtension({
+const catalogEntityPage = PageBlueprint.make({
   name: 'entity',
   // ...
 });
 
 // The name is omitted, because the catalog plugin only provides a single extension of this kind
 // The final ID for this extension will be 'search-result-list-item:catalog'
-const catalogSearchResultListItem = createSearchResultListItemExtension({
+const catalogSearchResultListItem = SearchResultListItemBlueprint.make({
   // ...
 });
 
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx
similarity index 77%
rename from packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
rename to packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx
index 3bdcd3a7cc..b3e926e57c 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx
@@ -16,27 +16,27 @@
 
 import React from 'react';
 import { coreExtensionData } from './coreExtensionData';
-import { createExtensionKind } from './createExtensionKind';
+import { createExtensionBlueprint } from './createExtensionBlueprint';
 import { createExtensionTester } from '@backstage/frontend-test-utils';
 
-describe('createExtensionKind', () => {
-  it('should allow creation of extension kinds', () => {
-    const TestExtension = createExtensionKind({
+describe('createExtensionBlueprint', () => {
+  it('should allow creation of extension blueprints', () => {
+    const TestExtensionBlueprint = createExtensionBlueprint({
       kind: 'test-extension',
       attachTo: { id: 'test', input: 'default' },
       output: {
         element: coreExtensionData.reactElement,
       },
-      factory(_, options: { text: string }) {
+      factory(_, params: { text: string }) {
         return {
-          element: <h1>{options.text}</h1>,
+          element: <h1>{params.text}</h1>,
         };
       },
     });
 
-    const extension = TestExtension.new({
+    const extension = TestExtensionBlueprint.make({
       name: 'my-extension',
-      options: {
+      params: {
         text: 'Hello, world!',
       },
     });
@@ -72,27 +72,27 @@ describe('createExtensionKind', () => {
   });
 
   it('should allow overriding of the default factory', () => {
-    const TestExtension = createExtensionKind({
+    const TestExtensionBlueprint = createExtensionBlueprint({
       kind: 'test-extension',
       attachTo: { id: 'test', input: 'default' },
       output: {
         element: coreExtensionData.reactElement,
       },
-      factory(_, options: { text: string }) {
+      factory(_, params: { text: string }) {
         return {
-          element: <h1>{options.text}</h1>,
+          element: <h1>{params.text}</h1>,
         };
       },
     });
 
-    const extension = TestExtension.new({
+    const extension = TestExtensionBlueprint.make({
       name: 'my-extension',
-      options: {
+      params: {
         text: 'Hello, world!',
       },
-      factory(_, options: { text: string }) {
+      factory(_, params: { text: string }) {
         return {
-          element: <h2>{options.text}</h2>,
+          element: <h2>{params.text}</h2>,
         };
       },
     });
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts
similarity index 90%
rename from packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
rename to packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts
index 1212365712..74d2eeadf1 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionKind.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts
@@ -29,7 +29,7 @@ import {
 /**
  * @public
  */
-export interface CreateExtensionKindOptions<
+export interface CreateExtensionBlueprintOptions<
   TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
@@ -55,13 +55,13 @@ export interface CreateExtensionKindOptions<
 /**
  * @public
  */
-export interface ExtensionKind<
+export interface ExtensionBlueprint<
   TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 > {
-  create(args: {
+  make(args: {
     namespace?: string;
     name?: string;
     attachTo?: { id: string; input: string };
@@ -77,6 +77,7 @@ export interface ExtensionKind<
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
           context?: {
+            node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
@@ -91,14 +92,14 @@ export interface ExtensionKind<
 /**
  * @internal
  */
-class ExtensionKindImpl<
+class ExtensionBlueprintImpl<
   TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 > {
   constructor(
-    private readonly options: CreateExtensionKindOptions<
+    private readonly options: CreateExtensionBlueprintOptions<
       TParams,
       TInputs,
       TOutput,
@@ -106,7 +107,7 @@ class ExtensionKindImpl<
     >,
   ) {}
 
-  public create(args: {
+  public make(args: {
     namespace?: string;
     name?: string;
     attachTo?: { id: string; input: string };
@@ -122,6 +123,7 @@ class ExtensionKindImpl<
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
           context?: {
+            node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
@@ -186,13 +188,13 @@ class ExtensionKindImpl<
  *
  * @public
  */
-export function createExtensionKind<
+export function createExtensionBlueprint<
   TParams,
   TInputs extends AnyExtensionInputMap,
   TOutput extends AnyExtensionDataMap,
   TConfig,
 >(
-  options: CreateExtensionKindOptions<TParams, TInputs, TOutput, TConfig>,
-): ExtensionKind<TParams, TInputs, TOutput, TConfig> {
-  return new ExtensionKindImpl(options);
+  options: CreateExtensionBlueprintOptions<TParams, TInputs, TOutput, TConfig>,
+): ExtensionBlueprint<TParams, TInputs, TOutput, TConfig> {
+  return new ExtensionBlueprintImpl(options);
 }
diff --git a/packages/frontend-plugin-api/src/wiring/index.ts b/packages/frontend-plugin-api/src/wiring/index.ts
index 8fe9dc3a54..6d20368225 100644
--- a/packages/frontend-plugin-api/src/wiring/index.ts
+++ b/packages/frontend-plugin-api/src/wiring/index.ts
@@ -49,7 +49,7 @@ export {
   type FrontendFeature,
 } from './types';
 export {
-  type CreateExtensionKindOptions as ExtensionKindOptions,
-  ExtensionKind,
-  createExtensionKind,
-} from './createExtensionKind';
+  type CreateExtensionBlueprintOptions,
+  type ExtensionBlueprint,
+  createExtensionBlueprint,
+} from './createExtensionBlueprint';

From 5eaaf807fade6caae1a874744140ea469a46dbcc Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Thu, 18 Jul 2024 14:15:03 +0200
Subject: [PATCH 13/14] chore: fixing api-reports and changeset

Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md               |   8 +-
 packages/frontend-plugin-api/api-report.md | 179 ++++++++++-----------
 2 files changed, 88 insertions(+), 99 deletions(-)

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
index 879ecb5d14..d0a737f4af 100644
--- a/.changeset/dry-squids-tap.md
+++ b/.changeset/dry-squids-tap.md
@@ -2,12 +2,12 @@
 '@backstage/frontend-plugin-api': patch
 ---
 
-Introduce a new way to create extension types and kinds, with `createExtensionKind`.
+Introduce a new way to encapsulate extension kinds that replaces the extension creator pattern with `createExtensionBlueprint`
 
-This allows the creation of extension with the following pattern:
+This allows the creation of extension instances with the following pattern:
 
 ```tsx
-// create the extension kind
+// create the extension blueprint which is used to create instances
 const EntityCardBlueprint = createExtensionBlueprint({
   kind: 'entity-card',
   attachTo: { id: 'test', input: 'default' },
@@ -21,7 +21,7 @@ const EntityCardBlueprint = createExtensionBlueprint({
   },
 });
 
-// create an instance of the extension kind with props
+// create an instance of the extension blueprint with params
 const testExtension = EntityCardBlueprint.make({
   name: 'foo',
   params: {
diff --git a/packages/frontend-plugin-api/api-report.md b/packages/frontend-plugin-api/api-report.md
index 48718f5375..858350044c 100644
--- a/packages/frontend-plugin-api/api-report.md
+++ b/packages/frontend-plugin-api/api-report.md
@@ -499,6 +499,51 @@ export function createExtension<
   options: CreateExtensionOptions<TOutput, TInputs, TConfig>,
 ): ExtensionDefinition<TConfig>;
 
+// @public
+export function createExtensionBlueprint<
+  TParams,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+>(
+  options: CreateExtensionBlueprintOptions<TParams, TInputs, TOutput, TConfig>,
+): ExtensionBlueprint<TParams, TInputs, TOutput, TConfig>;
+
+// @public (undocumented)
+export interface CreateExtensionBlueprintOptions<
+  TParams,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  attachTo: {
+    id: string;
+    input: string;
+  };
+  // (undocumented)
+  configSchema?: PortableSchema<TConfig>;
+  // (undocumented)
+  disabled?: boolean;
+  // (undocumented)
+  factory(
+    context: {
+      node: AppNode;
+      config: TConfig;
+      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+    },
+    params: TParams,
+  ): Expand<ExtensionDataValues<TOutput>>;
+  // (undocumented)
+  inputs?: TInputs;
+  // (undocumented)
+  kind: string;
+  // (undocumented)
+  namespace?: string;
+  // (undocumented)
+  output: TOutput;
+}
+
 // @public (undocumented)
 export function createExtensionDataRef<TData>(
   id: string,
@@ -522,16 +567,6 @@ export function createExtensionInput<
   }
 >;
 
-// @public
-export function createExtensionKind<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
->(
-  options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
-): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
-
 // @public (undocumented)
 export interface CreateExtensionOptions<
   TOutput extends AnyExtensionDataMap,
@@ -843,6 +878,45 @@ export interface Extension<TConfig> {
   readonly id: string;
 }
 
+// @public (undocumented)
+export interface ExtensionBlueprint<
+  TParams,
+  TInputs extends AnyExtensionInputMap,
+  TOutput extends AnyExtensionDataMap,
+  TConfig,
+> {
+  // (undocumented)
+  make(args: {
+    namespace?: string;
+    name?: string;
+    attachTo?: {
+      id: string;
+      input: string;
+    };
+    disabled?: boolean;
+    inputs?: TInputs;
+    output?: TOutput;
+    configSchema?: PortableSchema<TConfig>;
+    params: TParams;
+    factory?(
+      context: {
+        node: AppNode;
+        config: TConfig;
+        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
+        orignalFactory(
+          context?: {
+            node?: AppNode;
+            config?: TConfig;
+            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+          },
+          params?: TParams,
+        ): Expand<ExtensionDataValues<TOutput>>;
+      },
+      params: TParams,
+    ): Expand<ExtensionDataValues<TOutput>>;
+  }): ExtensionDefinition<TConfig>;
+}
+
 // @public (undocumented)
 export function ExtensionBoundary(
   props: ExtensionBoundaryProps,
@@ -923,91 +997,6 @@ export interface ExtensionInput<
   extensionData: TExtensionData;
 }
 
-// @public
-export class ExtensionKind<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  // (undocumented)
-  static create<
-    TOptions,
-    TInputs extends AnyExtensionInputMap,
-    TOutput extends AnyExtensionDataMap,
-    TConfig,
-  >(
-    options: ExtensionKindOptions<TOptions, TInputs, TOutput, TConfig>,
-  ): ExtensionKind<TOptions, TInputs, TOutput, TConfig>;
-  // (undocumented)
-  new(args: {
-    namespace?: string;
-    name?: string;
-    attachTo?: {
-      id: string;
-      input: string;
-    };
-    disabled?: boolean;
-    inputs?: TInputs;
-    output?: TOutput;
-    configSchema?: PortableSchema<TConfig>;
-    options: TOptions;
-    factory?(
-      context: {
-        node: AppNode;
-        config: TConfig;
-        inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-        orignalFactory(
-          context?: {
-            node?: AppNode;
-            config?: TConfig;
-            inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-          },
-          options?: TOptions,
-        ): Expand<ExtensionDataValues<TOutput>>;
-      },
-      options: TOptions,
-    ): Expand<ExtensionDataValues<TOutput>>;
-  }): ExtensionDefinition<TConfig>;
-}
-
-// @public (undocumented)
-export interface ExtensionKindOptions<
-  TOptions,
-  TInputs extends AnyExtensionInputMap,
-  TOutput extends AnyExtensionDataMap,
-  TConfig,
-> {
-  // (undocumented)
-  attachTo: {
-    id: string;
-    input: string;
-  };
-  // (undocumented)
-  configSchema?: PortableSchema<TConfig>;
-  // (undocumented)
-  disabled?: boolean;
-  // (undocumented)
-  factory(
-    context: {
-      node: AppNode;
-      config: TConfig;
-      inputs: Expand<ResolvedExtensionInputs<TInputs>>;
-    },
-    options: TOptions,
-  ): Expand<ExtensionDataValues<TOutput>>;
-  // (undocumented)
-  inputs?: TInputs;
-  // (undocumented)
-  kind: string;
-  // (undocumented)
-  name?: string;
-  // (undocumented)
-  namespace?: string;
-  // (undocumented)
-  output: TOutput;
-}
-
 // @public (undocumented)
 export interface ExtensionOverrides {
   // (undocumented)

From 3f257d25e26c51f21f6d63c3feecec59862eadb8 Mon Sep 17 00:00:00 2001
From: blam <ben@blam.sh>
Date: Thu, 18 Jul 2024 14:59:02 +0200
Subject: [PATCH 14/14] chore: switch around the params to the factories

Signed-off-by: blam <ben@blam.sh>
---
 .changeset/dry-squids-tap.md                  |  2 +-
 packages/frontend-plugin-api/api-report.md    |  6 +-
 .../wiring/createExtensionBlueprint.test.tsx  |  6 +-
 .../src/wiring/createExtensionBlueprint.ts    | 61 ++++++++-----------
 4 files changed, 33 insertions(+), 42 deletions(-)

diff --git a/.changeset/dry-squids-tap.md b/.changeset/dry-squids-tap.md
index d0a737f4af..613ec4b7cb 100644
--- a/.changeset/dry-squids-tap.md
+++ b/.changeset/dry-squids-tap.md
@@ -14,7 +14,7 @@ const EntityCardBlueprint = createExtensionBlueprint({
   output: {
     element: coreExtensionData.reactElement,
   },
-  factory(_, params: { text: string }) {
+  factory(params: { text: string }) {
     return {
       element: <h1>{params.text}</h1>,
     };
diff --git a/packages/frontend-plugin-api/api-report.md b/packages/frontend-plugin-api/api-report.md
index 858350044c..342907e096 100644
--- a/packages/frontend-plugin-api/api-report.md
+++ b/packages/frontend-plugin-api/api-report.md
@@ -527,12 +527,12 @@ export interface CreateExtensionBlueprintOptions<
   disabled?: boolean;
   // (undocumented)
   factory(
+    params: TParams,
     context: {
       node: AppNode;
       config: TConfig;
       inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     },
-    params: TParams,
   ): Expand<ExtensionDataValues<TOutput>>;
   // (undocumented)
   inputs?: TInputs;
@@ -899,20 +899,20 @@ export interface ExtensionBlueprint<
     configSchema?: PortableSchema<TConfig>;
     params: TParams;
     factory?(
+      params: TParams,
       context: {
         node: AppNode;
         config: TConfig;
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
+          params?: TParams,
           context?: {
             node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
-          params?: TParams,
         ): Expand<ExtensionDataValues<TOutput>>;
       },
-      params: TParams,
     ): Expand<ExtensionDataValues<TOutput>>;
   }): ExtensionDefinition<TConfig>;
 }
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx
index b3e926e57c..c7b077bdbd 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.test.tsx
@@ -27,7 +27,7 @@ describe('createExtensionBlueprint', () => {
       output: {
         element: coreExtensionData.reactElement,
       },
-      factory(_, params: { text: string }) {
+      factory(params: { text: string }) {
         return {
           element: <h1>{params.text}</h1>,
         };
@@ -78,7 +78,7 @@ describe('createExtensionBlueprint', () => {
       output: {
         element: coreExtensionData.reactElement,
       },
-      factory(_, params: { text: string }) {
+      factory(params: { text: string }) {
         return {
           element: <h1>{params.text}</h1>,
         };
@@ -90,7 +90,7 @@ describe('createExtensionBlueprint', () => {
       params: {
         text: 'Hello, world!',
       },
-      factory(_, params: { text: string }) {
+      factory(params: { text: string }) {
         return {
           element: <h2>{params.text}</h2>,
         };
diff --git a/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts
index 74d2eeadf1..6c79017a0a 100644
--- a/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts
+++ b/packages/frontend-plugin-api/src/wiring/createExtensionBlueprint.ts
@@ -43,12 +43,12 @@ export interface CreateExtensionBlueprintOptions<
   output: TOutput;
   configSchema?: PortableSchema<TConfig>;
   factory(
+    params: TParams,
     context: {
       node: AppNode;
       config: TConfig;
       inputs: Expand<ResolvedExtensionInputs<TInputs>>;
     },
-    params: TParams,
   ): Expand<ExtensionDataValues<TOutput>>;
 }
 
@@ -71,20 +71,20 @@ export interface ExtensionBlueprint<
     configSchema?: PortableSchema<TConfig>;
     params: TParams;
     factory?(
+      params: TParams,
       context: {
         node: AppNode;
         config: TConfig;
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
+          params?: TParams,
           context?: {
             node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
-          params?: TParams,
         ): Expand<ExtensionDataValues<TOutput>>;
       },
-      params: TParams,
     ): Expand<ExtensionDataValues<TOutput>>;
   }): ExtensionDefinition<TConfig>;
 }
@@ -117,20 +117,20 @@ class ExtensionBlueprintImpl<
     configSchema?: PortableSchema<TConfig>;
     params: TParams;
     factory?(
+      params: TParams,
       context: {
         node: AppNode;
         config: TConfig;
         inputs: Expand<ResolvedExtensionInputs<TInputs>>;
         orignalFactory(
+          params?: TParams,
           context?: {
             node?: AppNode;
             config?: TConfig;
             inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
           },
-          params?: TParams,
         ): Expand<ExtensionDataValues<TOutput>>;
       },
-      params: TParams,
     ): Expand<ExtensionDataValues<TOutput>>;
   }): ExtensionDefinition<TConfig> {
     return createExtension({
@@ -144,39 +144,30 @@ class ExtensionBlueprintImpl<
       configSchema: args.configSchema ?? this.options.configSchema, // TODO: some config merging or smth
       factory: ({ node, config, inputs }) => {
         if (args.factory) {
-          return args.factory(
-            {
-              node,
-              config,
-              inputs,
-              orignalFactory: (
-                innerContext?: {
-                  config?: TConfig;
-                  inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
-                },
-                innerParams?: TParams,
-              ) =>
-                this.options.factory(
-                  {
-                    node,
-                    config: innerContext?.config ?? config,
-                    inputs: innerContext?.inputs ?? inputs,
-                  },
-                  innerParams ?? args.params,
-                ),
-            },
-            args.params,
-          );
-        }
-
-        return this.options.factory(
-          {
+          return args.factory(args.params, {
             node,
             config,
             inputs,
-          },
-          args.params,
-        );
+            orignalFactory: (
+              innerParams?: TParams,
+              innerContext?: {
+                config?: TConfig;
+                inputs?: Expand<ResolvedExtensionInputs<TInputs>>;
+              },
+            ) =>
+              this.options.factory(innerParams ?? args.params, {
+                node,
+                config: innerContext?.config ?? config,
+                inputs: innerContext?.inputs ?? inputs,
+              }),
+          });
+        }
+
+        return this.options.factory(args.params, {
+          node,
+          config,
+          inputs,
+        });
       },
     });
   }