@kosdev-code/kos-nx-plugin 2.0.30 → 2.0.32

package/src/generators/kos-add-future-to-model/lib/registration-transformer.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.RegistrationFileTransformer = void 0;
+class RegistrationFileTransformer {
+    tree;
+    options;
+    constructor(tree, options) {
+        this.tree = tree;
+        this.options = options;
+    }
+    transform() {
+        const { registrationFilePath } = this.options;
+        if (!registrationFilePath || !this.tree.exists(registrationFilePath)) {
+            console.warn("Registration file not found, skipping registration updates");
+            return;
+        }
+        let content = this.tree.read(registrationFilePath, "utf-8");
+        content = this.addTypeCast(content);
+        content = this.updateDocumentation(content);
+        this.tree.write(registrationFilePath, content);
+    }
+    addTypeCast(content) {
+        const { nameProperCase } = this.options;
+        // Find the registration factory instantiation and add type cast
+        const factoryRegex = new RegExp(`class: ${nameProperCase}ModelImpl,`);
+        const replacement = `class: ${nameProperCase}ModelImpl as any,  // Type cast needed for Future intersection`;
+        return content.replace(factoryRegex, replacement);
+    }
+    updateDocumentation(content) {
+        const { nameProperCase, futureType } = this.options;
+        // Add Future support documentation after the main description
+        const descriptionRegex = new RegExp(`(\\* The registration bean includes convenience methods for creating and working with ${nameProperCase}Model instances\\.)`);
+        const futureDocumentation = `$1
+ * 
+ * ## Future Support
+ * This model includes ${futureType} Future support for tracking long-running operations with:
+ * - Progress tracking (0-1) with reactive updates  
+ * - Status messages during operation
+ * - Cancellation support with bi-directional AbortController integration
+ * - Reactive integration for UI updates${futureType === "complete"
+            ? "\n * - Internal access to Future state for custom logic and computed properties"
+            : ""}`;
+        if (content.match(descriptionRegex)) {
+            content = content.replace(descriptionRegex, futureDocumentation);
+        }
+        // Add Future usage examples to factory documentation
+        const factoryExampleRegex = /(\*\s+\}\);?\s*\*\s+```)/;
+        const futureExample = `$1
+ * 
+ * // Example: Accessing Future state (when a Future is active)
+ * const isRunning = model.futureIsRunning;
+ * const progress = model.futureProgress;  // 0-1
+ * const status = model.futureStatus;      // Current status message
+ * \`\`\``;
+        if (content.match(factoryExampleRegex)) {
+            content = content.replace(factoryExampleRegex, futureExample);
+        }
+        // Add Future capabilities to predicate examples
+        const predicateExampleRegex = /(\*\s+model\.updateAvailability\(false\);?\s*\*\s+\})/;
+        const predicateFutureExample = `$1
+ *    
+ *    // Future capabilities are also available
+ *    const isRunning = model.futureIsRunning;
+ *    const progress = model.futureProgress;
+ * }`;
+        if (content.match(predicateExampleRegex)) {
+            content = content.replace(predicateExampleRegex, predicateFutureExample);
+        }
+        return content;
+    }
+}
+exports.RegistrationFileTransformer = RegistrationFileTransformer;
+//# sourceMappingURL=registration-transformer.js.map

package/src/generators/kos-add-future-to-model/lib/registration-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"registration-transformer.js","sourceRoot":"","sources":["../../../../../../../../packages/plugins/kos-nx-plugin/src/generators/kos-add-future-to-model/lib/registration-transformer.ts"],"names":[],"mappings":";;;AAGA,MAAa,2BAA2B;IAE5B;IACA;IAFV,YACU,IAAU,EACV,OAA4C;QAD5C,SAAI,GAAJ,IAAI,CAAM;QACV,YAAO,GAAP,OAAO,CAAqC;IACnD,CAAC;IAEJ,SAAS;QACP,MAAM,EAAE,oBAAoB,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAE9C,IAAI,CAAC,oBAAoB,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,MAAM,CAAC,oBAAoB,CAAC,EAAE,CAAC;YACrE,OAAO,CAAC,IAAI,CACV,4DAA4D,CAC7D,CAAC;YACF,OAAO;QACT,CAAC;QAED,IAAI,OAAO,GAAG,IAAI,CAAC,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,OAAO,CAAE,CAAC;QAE7D,OAAO,GAAG,IAAI,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;QACpC,OAAO,GAAG,IAAI,CAAC,mBAAmB,CAAC,OAAO,CAAC,CAAC;QAE5C,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,oBAAoB,EAAE,OAAO,CAAC,CAAC;IACjD,CAAC;IAEO,WAAW,CAAC,OAAe;QACjC,MAAM,EAAE,cAAc,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAExC,gEAAgE;QAChE,MAAM,YAAY,GAAG,IAAI,MAAM,CAAC,UAAU,cAAc,YAAY,CAAC,CAAC;QAEtE,MAAM,WAAW,GAAG,UAAU,cAAc,gEAAgE,CAAC;QAE7G,OAAO,OAAO,CAAC,OAAO,CAAC,YAAY,EAAE,WAAW,CAAC,CAAC;IACpD,CAAC;IAEO,mBAAmB,CAAC,OAAe;QACzC,MAAM,EAAE,cAAc,EAAE,UAAU,EAAE,GAAG,IAAI,CAAC,OAAO,CAAC;QAEpD,8DAA8D;QAC9D,MAAM,gBAAgB,GAAG,IAAI,MAAM,CACjC,yFAAyF,cAAc,qBAAqB,CAC7H,CAAC;QAEF,MAAM,mBAAmB,GAAG;;;yBAGP,UAAU;;;;0CAKhC,UAAU,KAAK,UAAU;YACvB,CAAC,CAAC,iFAAiF;YACnF,CAAC,CAAC,EACN,EAAE,CAAC;QAEA,IAAI,OAAO,CAAC,KAAK,CAAC,gBAAgB,CAAC,EAAE,CAAC;YACpC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,gBAAgB,EAAE,mBAAmB,CAAC,CAAC;QACnE,CAAC;QAED,qDAAqD;QACrD,MAAM,mBAAmB,GAAG,0BAA0B,CAAC;QAEvD,MAAM,aAAa,GAAG;;;;;;UAMhB,CAAC;QAEP,IAAI,OAAO,CAAC,KAAK,CAAC,mBAAmB,CAAC,EAAE,CAAC;YACvC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,mBAAmB,EAAE,aAAa,CAAC,CAAC;QAChE,CAAC;QAED,gDAAgD;QAChD,MAAM,qBAAqB,GACzB,uDAAuD,CAAC;QAE1D,MAAM,sBAAsB,GAAG;;;;;KAK9B,CAAC;QAEF,IAAI,OAAO,CAAC,KAAK,CAAC,qBAAqB,CAAC,EAAE,CAAC;YACzC,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,qBAAqB,EAAE,sBAAsB,CAAC,CAAC;QAC3E,CAAC;QAED,OAAO,OAAO,CAAC;IACjB,CAAC;CACF;AA5FD,kEA4FC"}

package/src/generators/kos-add-future-to-model/lib/service-transformer.d.ts

@@ -0,0 +1,13 @@
+import { Tree } from "@nx/devkit";
+import { NormalizedKosAddFutureToModelSchema } from "../schema";
+export declare class ServiceFileTransformer {
+    private tree;
+    private options;
+    constructor(tree: Tree, options: NormalizedKosAddFutureToModelSchema);
+    transform(): void;
+    private createServicesFile;
+    private addFutureImports;
+    private addFutureService;
+    private addProgressTypes;
+}
+//# sourceMappingURL=service-transformer.d.ts.map

package/src/generators/kos-add-future-to-model/lib/service-transformer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-transformer.d.ts","sourceRoot":"","sources":["../../../../../../../../packages/plugins/kos-nx-plugin/src/generators/kos-add-future-to-model/lib/service-transformer.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,IAAI,EAAE,MAAM,YAAY,CAAC;AAClC,OAAO,EAAE,mCAAmC,EAAE,MAAM,WAAW,CAAC;AAEhE,qBAAa,sBAAsB;IAE/B,OAAO,CAAC,IAAI;IACZ,OAAO,CAAC,OAAO;gBADP,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,mCAAmC;IAGtD,SAAS,IAAI,IAAI;IAkBjB,OAAO,CAAC,kBAAkB;IA+E1B,OAAO,CAAC,gBAAgB;IA8BxB,OAAO,CAAC,gBAAgB;IAkCxB,OAAO,CAAC,gBAAgB;CA4BzB"}

package/src/generators/kos-add-future-to-model/lib/service-transformer.js

@@ -0,0 +1,178 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ServiceFileTransformer = void 0;
+class ServiceFileTransformer {
+    tree;
+    options;
+    constructor(tree, options) {
+        this.tree = tree;
+        this.options = options;
+    }
+    transform() {
+        const { servicesFilePath } = this.options;
+        if (!servicesFilePath || !this.tree.exists(servicesFilePath)) {
+            // Create services file if it doesn't exist
+            this.createServicesFile();
+            return;
+        }
+        let content = this.tree.read(servicesFilePath, "utf-8");
+        content = this.addFutureImports(content);
+        content = this.addFutureService(content);
+        content = this.addProgressTypes(content);
+        this.tree.write(servicesFilePath, content);
+    }
+    createServicesFile() {
+        const { servicesFilePath, nameProperCase, nameDashCase, nameLowerCase } = this.options;
+        if (!servicesFilePath) {
+            return;
+        }
+        const content = `import {
+  KosLog,
+  type ClientResponse,
+  type DeepRequired,
+  type ElementType,
+  type ServiceResponse,
+  type FutureResponse
+} from '@kosdev-code/kos-ui-sdk';
+
+import API, { type KosApi, type ApiPath } from '../../../utils/service';
+
+const log = KosLog.createLogger({name: "${nameDashCase}-service", group: "Services"});
+
+const SERVICE_PATH: ApiPath = "ENTER_SERVICE_PATH"
+export type ${nameProperCase}ClientResponse = ClientResponse<
+  KosApi,
+  typeof SERVICE_PATH,
+  'get'
+>;
+export type ${nameProperCase}Response = DeepRequired<${nameProperCase}ClientResponse>;
+
+/**
+ * @category Service
+ * Retrieves the initial ${nameLowerCase} data.
+ */
+export const get${nameProperCase} = async (): Promise<ServiceResponse<${nameProperCase}Response>> => {
+  log.debug('sending GET for ${nameLowerCase}');
+  return await API.get(SERVICE_PATH);
+};
+
+/**
+ * @category Service - Future Operation
+ * Placeholder for a long-running operation that returns a Future for progress tracking
+ * 
+ * Replace this with your actual long-running service operation
+ */
+export const perform${nameProperCase}Operation = async (): Promise<FutureResponse> => {
+  // TODO: Implement your long-running service operation here
+  // This should return a Future that can be tracked for progress
+  
+  log.debug('starting long-running ${nameLowerCase} operation');
+  
+  // Example pattern:
+  // return API.post(OPERATION_SERVICE_PATH, {
+  //   // operation parameters
+  // });
+  
+  // Placeholder - replace with actual implementation
+  throw new Error('perform${nameProperCase}Operation not yet implemented');
+};
+
+// Additional Future-aware service types (add as needed)
+export type ${nameProperCase}OperationProgress = {
+  // Define your progress data structure here
+  stage: string;
+  percentComplete: number;
+  currentItem?: string;
+  totalItems?: number;
+};
+
+export type ${nameProperCase}OperationResult = {
+  // Define your operation result structure here
+  success: boolean;
+  message?: string; 
+  data?: any;
+};
+`;
+        this.tree.write(servicesFilePath, content);
+    }
+    addFutureImports(content) {
+        // Check if FutureResponse is already imported
+        if (content.includes("FutureResponse")) {
+            return content;
+        }
+        // Add FutureResponse to existing import
+        const importRegex = /import {\s*([^}]*)\s*} from '@kosdev-code\/kos-ui-sdk';/;
+        const importMatch = content.match(importRegex);
+        if (importMatch) {
+            const existingImports = importMatch[1];
+            if (existingImports.includes("FutureResponse")) {
+                return content; // Already imported
+            }
+            // Clean up existing imports and add FutureResponse
+            const cleanedImports = existingImports.trim().replace(/,\s*$/, ''); // Remove trailing comma
+            const newImports = cleanedImports
+                ? `${cleanedImports},\n  type FutureResponse`
+                : `type FutureResponse`;
+            const newImportStatement = `import {\n  ${newImports}\n} from '@kosdev-code/kos-ui-sdk';`;
+            return content.replace(importMatch[0], newImportStatement);
+        }
+        return content;
+    }
+    addFutureService(content) {
+        const { nameProperCase, nameLowerCase } = this.options;
+        // Check if Future service already exists
+        if (content.includes(`perform${nameProperCase}Operation`)) {
+            return content;
+        }
+        const futureService = `
+/**
+ * @category Service - Future Operation
+ * Placeholder for a long-running operation that returns a Future for progress tracking
+ * 
+ * Replace this with your actual long-running service operation
+ */
+export const perform${nameProperCase}Operation = async (): Promise<FutureResponse> => {
+  // TODO: Implement your long-running service operation here
+  // This should return a Future that can be tracked for progress
+  
+  log.debug('starting long-running ${nameLowerCase} operation');
+  
+  // Example pattern:
+  // return API.post(OPERATION_SERVICE_PATH, {
+  //   // operation parameters
+  // });
+  
+  // Placeholder - replace with actual implementation
+  throw new Error('perform${nameProperCase}Operation not yet implemented');
+};`;
+        // Add at the end of the file
+        return content + "\n" + futureService;
+    }
+    addProgressTypes(content) {
+        const { nameProperCase } = this.options;
+        // Check if progress types already exist
+        if (content.includes(`${nameProperCase}OperationProgress`)) {
+            return content;
+        }
+        const progressTypes = `
+// Additional Future-aware service types (add as needed)
+export type ${nameProperCase}OperationProgress = {
+  // Define your progress data structure here
+  stage: string;
+  percentComplete: number;
+  currentItem?: string;
+  totalItems?: number;
+};
+
+export type ${nameProperCase}OperationResult = {
+  // Define your operation result structure here
+  success: boolean;
+  message?: string; 
+  data?: any;
+};`;
+        // Add at the end of the file
+        return content + "\n" + progressTypes;
+    }
+}
+exports.ServiceFileTransformer = ServiceFileTransformer;
+//# sourceMappingURL=service-transformer.js.map

package/src/generators/kos-add-future-to-model/lib/service-transformer.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-transformer.js","sourceRoot":"","sources":["../../../../../../../../packages/plugins/kos-nx-plugin/src/generators/kos-add-future-to-model/lib/service-transformer.ts"],"names":[],"mappings":"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"}

package/src/generators/kos-add-future-to-model/schema.d.ts

@@ -0,0 +1,24 @@
+export interface KosAddFutureToModelSchema {
+  modelName: string;
+  modelProject: string;
+  futureType: "minimal" | "complete";
+  modelPath?: string;
+  updateServices?: boolean;
+  dryRun?: boolean;
+}
+
+export interface NormalizedKosAddFutureToModelSchema
+  extends KosAddFutureToModelSchema {
+  nameDashCase: string;
+  nameProperCase: string;
+  nameCamelCase: string;
+  namePascalCase: string;
+  nameConstantCase: string;
+  nameLowerCase: string;
+  projectRoot: string;
+  sourceRoot: string;
+  modelFilePath: string;
+  servicesFilePath?: string;
+  registrationFilePath?: string;
+  internal: boolean;
+}

package/src/generators/kos-add-future-to-model/schema.json

@@ -0,0 +1,59 @@
+{
+  "$schema": "http://json-schema.org/schema",
+  "$id": "KosAddFutureToModel",
+  "title": "Add Future Support to Existing KOS Model",
+  "type": "object",
+  "properties": {
+    "modelName": {
+      "type": "string",
+      "description": "Name of the existing model to add Future support to",
+      "$default": {
+        "$source": "argv",
+        "index": 0
+      },
+      "x-prompt": "Which model do you want to add Future support to?"
+    },
+    "modelProject": {
+      "type": "string",
+      "description": "The project where the model is located",
+      "x-prompt": "Which project contains the model?",
+      "x-dropdown": "projects"
+    },
+    "futureType": {
+      "type": "string",
+      "description": "Type of Future support to add",
+      "enum": ["minimal", "complete"],
+      "default": "minimal",
+      "x-prompt": {
+        "message": "What type of Future support?",
+        "type": "list",
+        "items": [
+          {
+            "value": "minimal",
+            "label": "Minimal (external access only)"
+          },
+          {
+            "value": "complete",
+            "label": "Complete (internal + external access)"
+          }
+        ]
+      }
+    },
+    "modelPath": {
+      "type": "string",
+      "description": "Relative path to the model file within the project (optional - will be auto-detected)"
+    },
+    "updateServices": {
+      "type": "boolean",
+      "description": "Update the services file to include Future operations",
+      "default": true,
+      "x-prompt": "Update services file with Future operations?"
+    },
+    "dryRun": {
+      "type": "boolean",
+      "description": "Show what would be changed without making actual changes",
+      "default": false
+    }
+  },
+  "required": ["modelName", "modelProject"]
+}

package/src/generators/kos-companion-model/files/types/index.d.ts.template

@@ -3,8 +3,8 @@ import type { <%= modelNameProperCase %>Options, <%= modelNameProperCase %>Model
 
 
 export type <%= companionModelNameProperCase %>Options = IKosCompanionOptions<
-  <%= companionModelNameProperCase %>Model,
-  <%= companionModelNameProperCase %>Options
+  <%= modelNameProperCase %>Model,
+  <%= modelNameProperCase %>Options
 >;
 
 

package/src/generators/kos-companion-model/schema.d.ts

@@ -3,4 +3,5 @@ export interface KosCompanionModelGeneratorSchema {
   companionModelProject: string;
   modelName: string;
   modelProject: string;
+  companionPattern?: "composition" | "decorator";
 }

package/src/generators/kos-model/files/model/__nameDashCase__-model.ts.template

@@ -1,4 +1,8 @@
-<% if (internal) { %>import { kosModel<% if (parentAware) { %>, kosParentAware<% } %> } from "../../../core/core/decorators";
+<% const hasFutureSupport = futureAware && futureAware !== 'none'; %>
+<% const isCompleteFuture = futureAware === 'complete'; %>
+<% const isCompositionCompanion = companion && companionPattern === 'composition'; %>
+<% const isDecoratorCompanion = companion && companionPattern === 'decorator'; %>
+<% if (internal) { %>import { kosModel<% if (parentAware) { %>, kosParentAware<% } %><% if (hasFutureSupport) { %>, kosFuture<% } %> } from "../../../core/core/decorators";
 import type {
   IKosDataModel,
   KosContextLogger,
@@ -6,29 +10,56 @@ import type {
 } from "../../../core/core/kosModel";
 import type { IKosIdentifiable } from "../../../core/core/types";
 import type { PublicModelInterface } from "../../../core/types";
-<% } else { %>import type { KosContextLogger, KosCreationContext, IKosDataModel, IKosIdentifiable, PublicModelInterface<% if (parentAware) { %>, kosParentAware<% } %>  } from "@kosdev-code/kos-ui-sdk";
-import { kosModel } from "@kosdev-code/kos-ui-sdk";
+<% if (hasFutureSupport) { %>import type { 
+  ExternalFutureInterface,
+  FutureHandlerContainer<% if (isCompleteFuture) { %>,
+  FutureStateAccessor,
+  FutureUpdateHandler<% } %>,
+  FutureAwareContainer,
+  IFutureModel
+} from "../../../models/types/future-interfaces";
+import { setup<% if (isCompleteFuture) { %>Complete<% } else { %>Minimal<% } %>FutureSupport } from "../../../models/utils/kosmodel-compatible-future-mixin";<% } %>
+<% if (isDecoratorCompanion) { %>import { setupCompanionDecoratorMixin, CompanionWithMixin } from "../../../models/utils/kosmodel-interface-companion-mixin";<% } %>
+<% } else { %>import type { KosContextLogger, KosCreationContext, IKosDataModel, IKosIdentifiable, PublicModelInterface<% if (hasFutureSupport) { %>, ExternalFutureInterface, FutureHandlerContainer<% if (isCompleteFuture) { %>, FutureStateAccessor, FutureUpdateHandler<% } %>, FutureAwareContainer, IFutureModel<% } %><% if (isDecoratorCompanion) { %>, CompanionWithMixin<% } %>  } from "@kosdev-code/kos-ui-sdk";
+import { kosModel<% if (parentAware) { %>, kosParentAware<% } %><% if (hasFutureSupport) { %>, kosFuture, setup<% if (isCompleteFuture) { %>Complete<% } else { %>Minimal<% } %>FutureSupport<% } %><% if (isDecoratorCompanion) { %>, setupCompanionDecoratorMixin<% } %> } from "@kosdev-code/kos-ui-sdk";
 <% } %>
 import type { <%= nameProperCase %>Options} from "./types";
+<% if (hasFutureSupport) { %>import type { <%= nameProperCase %>OperationProgress } from "./services";<% } %>
 
 <% if (companion) {%>
 import type { <%= companionModelProperCase %>Model } from "<%= companionModelProject %>";
 <% } %>
 export const MODEL_TYPE = "<%= nameDashCase %>-model";
 
-export type <%= nameProperCase %>Model = PublicModelInterface<<%= nameProperCase %>ModelImpl>;
+export type <%= nameProperCase %>Model = PublicModelInterface<<%= nameProperCase %>ModelImpl><% if (hasFutureSupport) { %> & ExternalFutureInterface<<%= nameProperCase %>OperationProgress><% } %><% if (isDecoratorCompanion) { %> & CompanionWithMixin<<%= companionModelProperCase %>Model><% } %>;
 
 <% if (parentAware) { %>@kosParentAware()<% } %>
 @kosModel(MODEL_TYPE)
-export class <%= nameProperCase %>ModelImpl implements  IKosDataModel, IKosIdentifiable  {
+export class <%= nameProperCase %>ModelImpl implements  IKosDataModel, IKosIdentifiable<% if (isCompleteFuture) { %>, FutureUpdateHandler<% } %>  {
     id: string;
     private logger: KosContextLogger;
-    <% if (companion) { %>private <%= companionModelCamelCase %>: <%= companionModelProperCase %>Model;<% } %>
+    <% if (isCompositionCompanion) { %>
+    // Composition pattern - explicit parent access
+    public readonly parent: <%= companionModelProperCase %>Model;
+    <% } %>
+    <% if (hasFutureSupport) { %>
+    // Future support properties - guaranteed by framework
+    public futureHandler!: FutureAwareContainer<<%= nameProperCase %>OperationProgress>;<% if (isCompleteFuture) { %>
+    public future?: IFutureModel<<%= nameProperCase %>OperationProgress>;  // Used internally for progress checks and custom logic<% } %><% } %>
+    
     constructor(modelId: string, options: <%= nameProperCase %>Options, context: KosCreationContext) {
         this.id = modelId;
         this.logger = context.logger;
-        <% if (companion) { %>
-        this.<%= companionModelCamelCase %> = options.companionParent;
+        <% if (isCompositionCompanion) { %>
+        // Set parent from companionParent option for composition pattern
+        this.parent = options.companionParent;
+        <% } else if (isDecoratorCompanion) { %>
+        // Setup decorator mixin for transparent parent access
+        setupCompanionDecoratorMixin(this, options.companionParent);
+        <% } %>
+        <% if (hasFutureSupport) { %>
+        // Initialize Future support
+        setup<% if (isCompleteFuture) { %>Complete<% } else { %>Minimal<% } %>FutureSupport(this);
         <% } %>
         if (options) {
         // Assign options properties here.
@@ -39,6 +70,60 @@ export class <%= nameProperCase %>ModelImpl implements  IKosDataModel, IKosIdent
         // Update model properties here.
     }
     
+    <% if (hasFutureSupport) { %>
+    /**
+     * Placeholder method for Future operations
+     * Replace this with your actual long-running operation
+     */
+    @kosFuture()
+    async performLongRunningOperation(): Promise<void> {
+        // TODO: Implement your long-running operation here
+        // This method should use a service that returns a Future for progress tracking
+        
+        this.logger.debug(`Starting long-running operation for ${this.id}`);
+        
+        // Example implementation pattern using services:
+        // import { perform<%= nameProperCase %>Operation } from './services';
+        // 
+        // try {
+        //   const future = await perform<%= nameProperCase %>Operation();
+        //   return this.futureHandler.setFuture(future);
+        // } catch (error) {
+        //   this.logger.error(`Failed to start operation for ${this.id}:`, error);
+        //   throw error;
+        // }
+        
+        // Placeholder that doesn't actually do anything
+        await new Promise(resolve => setTimeout(resolve, 1000));
+        
+        this.logger.debug(`Completed long-running operation for ${this.id}`);
+    }
+    <% } %>
+    
+    <% if (isCompleteFuture) { %>
+    /**
+     * Optional: Custom Future update handling
+     * Called whenever the Future state changes (progress, status, completion, etc.)
+     */
+    onFutureUpdate(update: IFutureModel<<%= nameProperCase %>OperationProgress>): void {
+        // Add custom Future update logic here
+        // Examples:
+        // - Log progress milestones
+        // - Update derived state based on progress
+        // - Handle specific error conditions
+        // - Trigger notifications at certain thresholds
+        
+        this.logger.debug(`Future update for ${this.id}:`, {
+            progress: update.progress,
+            status: update.status,
+            endState: update.endState,
+            // Access typed progress data:
+            stage: update.data?.stage,
+            percentComplete: update.data?.percentComplete
+        });
+    }
+    <% } %>
+    
     // -------------------LIFECYCLE----------------------------
     
 

package/src/generators/kos-model/files/model/__nameDashCase__-registration.ts.template

@@ -1,12 +1,26 @@
+<% const hasFutureSupport = futureAware && futureAware !== 'none'; %>
+<% const hasCompanionSupport = companion; %>
+<% const needsAnyCast = hasFutureSupport || hasCompanionSupport; %>
 import {  <% if (singleton) { %>Singleton<% } %>KosModelRegistrationFactory } from "<% if (internal) {%>../../../core/core/registration<% } else { %>@kosdev-code/kos-ui-sdk<% } %>";
 import type { <%= nameProperCase %>Options } from "./types";
-import { <%= nameProperCase %>ModelImpl, MODEL_TYPE } from "./<%= nameDashCase %>-model";
-import type { <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
+import { <%= nameProperCase %>ModelImpl, MODEL_TYPE, <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
 
 /**
  * # <%= nameProperCase %>
  *
  * The registration bean includes convenience methods for creating and working with <%= nameProperCase %>Model instances.
+<% if (hasFutureSupport) { %>
+ * 
+ * ## Future Support
+ * This model includes <%= futureAware %> Future support for tracking long-running operations with:
+ * - Progress tracking (0-1) with reactive updates  
+ * - Status messages during operation
+ * - Cancellation support with bi-directional AbortController integration
+ * - Reactive integration for UI updates
+<% if (futureAware === 'complete') { %>
+ * - Internal access to Future state for custom logic and computed properties
+<% } %>
+<% } %>
  *
  * ## type
  * The type property is a string that identifies the model type.
@@ -36,6 +50,13 @@ import type { <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
  * const model = <%= nameProperCase %>.factory({
  *   // Add option data
  * });
+<% if (hasFutureSupport) { %>
+ * 
+ * // Example: Accessing Future state (when a Future is active)
+ * const isRunning = model.futureIsRunning;
+ * const progress = model.futureProgress;  // 0-1
+ * const status = model.futureStatus;      // Current status message
+<% } %>
  * ```
  <% } else { %>
  * The factory function is a curried function that takes the model id as the first argument and the options as the second argument.
@@ -48,6 +69,13 @@ import type { <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
  * const model = <%= nameProperCase %>.factory("<%= nameCamelCase %>Id")({
  *   // Add option data
  * });
+<% if (hasFutureSupport) { %>
+ * 
+ * // Example: Accessing Future state (when a Future is active)
+ * const isRunning = model.futureIsRunning;
+ * const progress = model.futureProgress;  // 0-1
+ * const status = model.futureStatus;      // Current status message
+<% } %>
  * ```
  <% } %>
 
@@ -65,6 +93,12 @@ import type { <%= nameProperCase %>Model } from "./<%= nameDashCase %>-model";
  *    // if the function evaluates to true, the model is narrowed down to <%= nameProperCase %>Model
  *    // and the compiler will know that the model has the <%= nameProperCase %>Model interface
  *    model.updateAvailability(false);
+<% if (hasFutureSupport) { %>
+ *    
+ *    // Future capabilities are also available
+ *    const isRunning = model.futureIsRunning;
+ *    const progress = model.futureProgress;
+<% } %>
  * }
  * ```
  *
@@ -105,6 +139,6 @@ export const <%= nameProperCase %> = new <% if (singleton) { %>Singleton<% } %>K
   <%= nameProperCase %>Model,
   <%= nameProperCase %>Options
 >({
-  class: <%= nameProperCase %>ModelImpl,
+  class: <%= nameProperCase %>ModelImpl<% if (needsAnyCast) { %> as any<% } %>,  <% if (needsAnyCast) { %>// Type cast needed for<% if (hasFutureSupport && hasCompanionSupport) { %> Future and companion<% } else if (hasFutureSupport) { %> Future<% } else { %> companion<% } %> intersection<% } %>
   type: MODEL_TYPE,
 });

package/src/generators/kos-model/files/services/__nameDashCase__-services.ts.template

@@ -1,9 +1,11 @@
+<% const hasFutureSupport = futureAware && futureAware !== 'none'; %>
 import {
   KosLog,
   type ClientResponse,
   type DeepRequired,
   type ElementType,
-  type ServiceResponse
+  type ServiceResponse<% if (hasFutureSupport) { %>,
+  type FutureResponse<% } %>
 } from '@kosdev-code/kos-ui-sdk';
 
 import API, { type KosApi, type ApiPath } from '../../../utils/service';
@@ -25,4 +27,38 @@ export type <%= nameProperCase %>Response = DeepRequired<<%= nameProperCase %>Cl
 export const get<%= nameProperCase %> = async (): Promise<ServiceResponse<<%= nameProperCase %>Response>> => {
   log.debug('sending GET for  <%= name %>');
   return await API.get(SERVICE_PATH);
-};
+};
+
+<% if (hasFutureSupport) { %>
+/**
+ * @category Service - Future Operation
+ * Placeholder for a long-running operation that returns a Future for progress tracking
+ * 
+ * Replace this with your actual long-running service operation
+ */
+export const perform<%= nameProperCase %>Operation = async (): Promise<FutureResponse> => {
+  // TODO: Implement your long-running service operation here
+  // This should return a Future that can be tracked for progress
+  
+  log.debug('starting long-running <%= name %> operation');
+  
+  // Example pattern:
+  // return API.post(OPERATION_SERVICE_PATH, {
+  //   // operation parameters
+  // });
+  
+  // Placeholder - replace with actual implementation
+  throw new Error('perform<%= nameProperCase %>Operation not yet implemented');
+};
+
+// Additional Future-aware service types (add as needed)
+export type <%= nameProperCase %>OperationProgress = {
+  // Define your progress data structure here
+
+};
+
+export type <%= nameProperCase %>OperationResult = {
+  // Define your operation result structure here
+
+};
+<% } %>

package/src/generators/kos-model/generator.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../../../../../packages/plugins/kos-nx-plugin/src/generators/kos-model/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAWpB,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAEnD,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,uBAAuB,iBAwJjC;AAED,eAAe,iBAAiB,CAAC"}
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../../../../../packages/plugins/kos-nx-plugin/src/generators/kos-model/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,IAAI,EAKL,MAAM,YAAY,CAAC;AAWpB,OAAO,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAEnD,wBAAsB,iBAAiB,CACrC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,uBAAuB,iBA2JjC;AAED,eAAe,iBAAiB,CAAC"}