@common-stack/rollup-vite-utils 8.0.2-alpha.0 → 8.2.1-alpha.0

package/lib/tools/codegen/templates/common/scripts/fix-generated-types.js.template

@@ -0,0 +1,58 @@
+#!/usr/bin/env node
+
+/**
+ * Post-build script to fix malformed generated TypeScript definitions
+ * Fixes issues where JSDoc comments are incorrectly inserted into type definitions
+ */
+
+import { readFileSync, writeFileSync } from 'fs';
+import { fileURLToPath } from 'url';
+import { dirname, join } from 'path';
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+const generatedFilePath = join(__dirname, '../lib/generated/generated.d.ts');
+
+try {
+    console.log('Fixing generated type definitions...');
+
+    let content = readFileSync(generatedFilePath, 'utf8');
+
+    // Fix issue where JSDoc comments are inserted in the middle of type definitions
+    // Pattern 1: SchemaTypes.Scalars["URI"] /**...*/ ["input"]
+    // Should be: SchemaTypes.Scalars["URI"]["input"]
+    const jsdocInTypeRegex = /SchemaTypes\.Scalars\["URI"\]\s*\/\*\*[\s\S]*?\*\/\s*\["input"\]/g;
+    content = content.replace(jsdocInTypeRegex, 'SchemaTypes.Scalars["URI"]["input"]');
+
+    // Pattern 2: SchemaTypes.Scalars["Int"] /**...*/ ["input"]
+    // Remove JSDoc comments that appear between type accessors
+    const jsdocBetweenAccessorsRegex = /(SchemaTypes\.Scalars\["[^"]+"\])\s*\/\*\*[\s\S]*?\*\/\s*(\["input"\])/g;
+    content = content.replace(jsdocBetweenAccessorsRegex, '$1$2');
+
+    // Pattern 3: Fix closing JSDoc that appears as a standalone line followed by ["input"]
+    // Pattern: */ ["input"]>
+    // Should be removed - the JSDoc block shouldn't be there at all
+    const standaloneJsdocCloseRegex = /\s*\*\/\["input"\]>/g;
+    content = content.replace(standaloneJsdocCloseRegex, '>');
+
+    // Pattern 4: Fix multi-line JSDoc comments that break type definitions
+    // This happens when a JSDoc comment from another function is incorrectly placed
+    // between type accessor parts, e.g., ["String"] /**...*/ ["input"]
+    // Match any Scalar type followed by JSDoc followed by ["input"] or ["output"]
+    const multilineJsdocInTypeRegex = /(SchemaTypes\.Scalars\[[^\]]+\])\s*\/\*\*[\s\S]*?\*\/\s*(\["(?:input|output)"\])/g;
+    content = content.replace(multilineJsdocInTypeRegex, '$1$2');
+
+    // Pattern 5: Fix cases where JSDoc appears between other type accessors
+    // e.g., key: SchemaTypes.Scalars["String"] /**...*/ ["input"];
+    const typeAccessorJsdocRegex = /(\w+:\s*SchemaTypes\.\w+\[[^\]]+\])\s*\/\*\*[\s\S]*?\*\/\s*(\[[^\]]+\])/g;
+    content = content.replace(typeAccessorJsdocRegex, '$1$2');
+
+    // Write the fixed content back
+    writeFileSync(generatedFilePath, content, 'utf8');
+
+    console.log('✓ Successfully fixed generated type definitions');
+} catch (error) {
+    console.error('Error fixing generated types:', error.message);
+    process.exit(1);
+}

package/lib/tools/codegen/templates/common/src/apollo-context.ts.bk.template

@@ -0,0 +1,34 @@
+//@ts-nocheck
+import { DataProxy } from '@apollo/client/cache';
+import { ApolloClient } from '@apollo/client/index.js';
+import { CdmLogger } from '@cdm-logger/core';
+import express from 'express';
+import { IPreferncesTransformed } from '@common-stack/server-core';
+import { ClientContext } from './client-context';
+import { IHttpReq, IIGraphQlContext } from './generated/generated-models';
+
+/**
+ *
+ * Context
+ * @export
+ * @interface MyContext
+ */
+
+export interface IDataSources {}
+
+export interface IHttpMiddlewareContext {
+    req?: express.Request &
+        IHttpReq & {
+            logger?: CdmLogger.ILogger;
+            errors?: any;
+        };
+    res: express.Response;
+}
+
+export interface IGraphQLContext extends IIGraphQlContext {}
+export interface ServerContext extends IHttpMiddlewareContext, IGraphQLContext {
+    /** Backend Datasource */
+    dataSources: IDataSources;
+    preferences: IPreferncesTransformed[];
+}
+export interface MyContext extends ClientContext, ServerContext {}

package/lib/tools/codegen/templates/common/src/apollo-context.ts.template

@@ -4,7 +4,16 @@ import { ApolloClient } from '@apollo/client/index.js';
 import { CdmLogger } from '@cdm-logger/core';
 import express from 'express';
 import { IPreferncesTransformed } from '@common-stack/server-core';
-import { IUserContext, IUserProfile, IIAuth0Token, AuthStrategy } from './generated/generated-models';
+import { ClientContext } from './client-context';
+import {
+    IUserContext,
+    IUserProfile,
+    IIAuth0Token,
+    AuthStrategy,
+    ICdecodeParsedUri,
+    IHttpReq,
+    IIGraphQlContext,
+} from './generated/generated-models';
 /**
  *
  * Context
@@ -12,22 +21,6 @@ import { IUserContext, IUserProfile, IIAuth0Token, AuthStrategy } from './genera
  * @interface MyContext
  */
 
-export interface ClientContext {
-    /**
-     * Only application on the client side
-     */
-    cache: DataProxy;
-    /**
-     * Only application on the client side
-     */
-    getCacheKey: (options: { __typename: string; id?: string }) => string;
-    /**
-     * Only applicable on the client side
-     */
-    apolloClient: ApolloClient<any>; // deprecated use `client` instead
-    client: ApolloClient<any>;
-}
-
 export interface IDataSources {}
 
 export interface IHttpMiddlewareContext {
@@ -36,21 +29,21 @@ export interface IHttpMiddlewareContext {
         permissions?: any;
         cdecodeuri?: any;
         logger?: CdmLogger.ILogger;
+        currentPageUriSegments?: ICdecodeParsedUri;
         user?: IIAuth0Token;
         errors?: any;
         profile?: IUserProfile;
-    };
+    } & IHttpReq;
     res: express.Response;
 }
 
-export type IGraphQLContext = {
+export interface IGraphQLContext extends IIGraphQlContext {
     /**
      * current ip of the user fetched from the request
      */
     userIp: string;
 };
 export interface ServerContext extends IHttpMiddlewareContext, IGraphQLContext {
-    accessRoleService: any;
     user?: IIAuth0Token;
     userContext?: IUserContext;
     orgname?: string;

package/lib/tools/codegen/templates/common/src/client-context.ts.template

@@ -0,0 +1,19 @@
+
+import { DataProxy } from '@apollo/client/cache';
+import { ApolloClient } from '@apollo/client/index.js';
+
+export interface ClientContext {
+    /**
+     * Only application on the client side
+     */
+    cache: DataProxy;
+    /**
+     * Only application on the client side
+     */
+    getCacheKey: (options: { __typename: string; id?: string }) => string;
+    /**
+     * Only applicable on the client side
+     */
+    apolloClient: ApolloClient<any>; // deprecated use `client` instead
+    client: ApolloClient<any>;
+}

package/lib/tools/codegen/templates/common/src/core/disposable.ts.template

@@ -0,0 +1,93 @@
+/* tslint:disable */
+import { Event, Emitter } from './event';
+
+export interface Disposable {
+    /**
+     * Dispose this object.
+     */
+    dispose(): void;
+}
+
+export namespace Disposable {
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    export function is(arg: any): arg is Disposable {
+        return !!arg && typeof arg === 'object' && 'dispose' in arg && typeof arg['dispose'] === 'function';
+    }
+    export function create(func: () => void): Disposable {
+        return {
+            dispose: func
+        };
+    }
+    export const NULL = create(() => { });
+}
+
+export class DisposableCollection implements Disposable {
+
+    protected readonly disposables: Disposable[] = [];
+    protected readonly onDisposeEmitter = new Emitter<void>();
+
+    constructor(...toDispose: Disposable[]) {
+        toDispose.forEach(d => this.push(d));
+    }
+
+    /**
+     * This event is fired only once
+     * on first dispose of not empty collection.
+     */
+    get onDispose(): Event<void> {
+        return this.onDisposeEmitter.event;
+    }
+
+    protected checkDisposed(): void {
+        if (this.disposed && !this.disposingElements) {
+            this.onDisposeEmitter.fire(undefined);
+            this.onDisposeEmitter.dispose();
+        }
+    }
+
+    get disposed(): boolean {
+        return this.disposables.length === 0;
+    }
+
+    private disposingElements = false;
+    dispose(): void {
+        if (this.disposed || this.disposingElements) {
+            return;
+        }
+        this.disposingElements = true;
+        while (!this.disposed) {
+            try {
+                this.disposables.pop()!.dispose();
+            } catch (e) {
+                console.error(e);
+            }
+        }
+        this.disposingElements = false;
+        this.checkDisposed();
+    }
+
+    push(disposable: Disposable): Disposable {
+        const disposables = this.disposables;
+        disposables.push(disposable);
+        const originalDispose = disposable.dispose.bind(disposable);
+        const toRemove = Disposable.create(() => {
+            const index = disposables.indexOf(disposable);
+            if (index !== -1) {
+                disposables.splice(index, 1);
+            }
+            this.checkDisposed();
+        });
+        disposable.dispose = () => {
+            toRemove.dispose();
+            originalDispose();
+        };
+        return toRemove;
+    }
+
+    pushAll(disposables: Disposable[]): Disposable[] {
+        return disposables.map(disposable =>
+            this.push(disposable)
+        );
+    }
+
+}

package/lib/tools/codegen/templates/common/src/core/event.test.ts

@@ -0,0 +1,16 @@
+// import { expect } from 'vitest';
+// import { Emitter } from './event';
+
+// describe('Event Objects', () => {
+
+//     it('Emitter firing should be synchronous', () => {
+//         const emitter = new Emitter<undefined>();
+//         let counter = 0;
+
+//         emitter.event(() => counter++);
+//         expect(counter).eq(0);
+//         emitter.fire(undefined);
+//         expect(counter).eq(1);
+//     });
+
+// });

package/lib/tools/codegen/templates/common/src/core/event.ts.template

@@ -0,0 +1,326 @@
+/* tslint:disable */
+
+import { Disposable } from './disposable';
+import { MaybePromise } from './types';
+
+/**
+ * Represents a typed event.
+ */
+export interface Event<T> {
+
+    /**
+     *
+     * @param listener The listener function will be call when the event happens.
+     * @param thisArgs The 'this' which will be used when calling the event listener.
+     * @param disposables An array to which a {{IDisposable}} will be added.
+     * @return a disposable to remove the listener again.
+     */
+    (listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]): Disposable;
+    /**
+     * An emitter will print a warning if more listeners are added for this event.
+     * The event.maxListeners allows the limit to be modified for this specific event.
+     * The value can be set to 0 to indicate an unlimited number of listener.
+     */
+    maxListeners: number
+}
+
+export namespace Event {
+    const _disposable = { dispose(): void { } };
+    export const None: Event<any> = Object.assign(function (): { dispose(): void } { return _disposable; }, {
+        get maxListeners(): number { return 0; },
+        set maxListeners(maxListeners: number) { }
+    });
+
+    /**
+     * Given an event and a `map` function, returns another event which maps each element
+     * through the mapping function.
+     */
+    export function map<I, O>(event: Event<I>, mapFunc: (i: I) => O): Event<O> {
+        return Object.assign((listener: (e: O) => any, thisArgs?: any, disposables?: Disposable[]) => event(i => listener.call(thisArgs, mapFunc(i)), undefined, disposables), {
+            maxListeners: 0,
+        });
+    }
+}
+
+type Callback = (...args: any[]) => any;
+class CallbackList implements Iterable<Callback> {
+
+    private _callbacks: Function[] | undefined;
+    private _contexts: any[] | undefined;
+
+    get length(): number {
+        return this._callbacks && this._callbacks.length || 0;
+    }
+
+    public add(callback: Function, context: any = undefined, bucket?: Disposable[]): void {
+        if (!this._callbacks) {
+            this._callbacks = [];
+            this._contexts = [];
+        }
+        this._callbacks.push(callback);
+        this._contexts!.push(context);
+
+        if (Array.isArray(bucket)) {
+            bucket.push({ dispose: () => this.remove(callback, context) });
+        }
+    }
+
+    public remove(callback: Function, context: any = undefined): void {
+        if (!this._callbacks) {
+            return;
+        }
+
+        let foundCallbackWithDifferentContext = false;
+        for (let i = 0; i < this._callbacks.length; i++) {
+            if (this._callbacks[i] === callback) {
+                if (this._contexts![i] === context) {
+                    // callback & context match => remove it
+                    this._callbacks.splice(i, 1);
+                    this._contexts!.splice(i, 1);
+                    return;
+                } else {
+                    foundCallbackWithDifferentContext = true;
+                }
+            }
+        }
+
+        if (foundCallbackWithDifferentContext) {
+            throw new Error('When adding a listener with a context, you should remove it with the same context');
+        }
+    }
+
+    // tslint:disable-next-line:typedef
+    public [Symbol.iterator]() {
+        if (!this._callbacks) {
+            return [][Symbol.iterator]();
+        }
+        const callbacks = this._callbacks.slice(0);
+        const contexts = this._contexts!.slice(0);
+
+        return callbacks.map((callback, i) =>
+            (...args: any[]) => callback.apply(contexts[i], args)
+        )[Symbol.iterator]();
+    }
+
+    public invoke(...args: any[]): any[] {
+        const ret: any[] = [];
+        for (const callback of this) {
+            try {
+                ret.push(callback(...args));
+            } catch (e) {
+                console.error(e);
+            }
+        }
+        return ret;
+    }
+
+    public isEmpty(): boolean {
+        return !this._callbacks || this._callbacks.length === 0;
+    }
+
+    public dispose(): void {
+        this._callbacks = undefined;
+        this._contexts = undefined;
+    }
+}
+
+export interface EmitterOptions {
+    onFirstListenerAdd?: Function;
+    onLastListenerRemove?: Function;
+}
+
+export class Emitter<T = any> {
+
+    private static LEAK_WARNING_THRESHHOLD = 175;
+
+    private static _noop = function (): void { };
+
+    private _event: Event<T>;
+    private _callbacks: CallbackList | undefined;
+    private _disposed = false;
+
+    private _leakingStacks: Map<string, number> | undefined;
+    private _leakWarnCountdown = 0;
+
+    constructor(
+        private _options?: EmitterOptions
+    ) { }
+
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event(): Event<T> {
+        if (!this._event) {
+            this._event = Object.assign((listener: (e: T) => any, thisArgs?: any, disposables?: Disposable[]) => {
+                if (!this._callbacks) {
+                    this._callbacks = new CallbackList();
+                }
+                if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+                    this._options.onFirstListenerAdd(this);
+                }
+                this._callbacks.add(listener, thisArgs);
+                const removeMaxListenersCheck = this.checkMaxListeners(this._event.maxListeners);
+
+                const result: Disposable = {
+                    dispose: () => {
+                        if (removeMaxListenersCheck) {
+                            removeMaxListenersCheck();
+                        }
+                        result.dispose = Emitter._noop;
+                        if (!this._disposed) {
+                            this._callbacks!.remove(listener, thisArgs);
+                            result.dispose = Emitter._noop;
+                            if (this._options && this._options.onLastListenerRemove && this._callbacks!.isEmpty()) {
+                                this._options.onLastListenerRemove(this);
+                            }
+                        }
+                    }
+                };
+                if (Array.isArray(disposables)) {
+                    disposables.push(result);
+                }
+
+                return result;
+            }, {
+                maxListeners: Emitter.LEAK_WARNING_THRESHHOLD
+            }
+            );
+        }
+        return this._event;
+    }
+
+    protected checkMaxListeners(maxListeners: number): (() => void) | undefined {
+        if (maxListeners === 0 || !this._callbacks) {
+            return undefined;
+        }
+        const listenerCount = this._callbacks.length;
+        if (listenerCount <= maxListeners) {
+            return undefined;
+        }
+
+        const popStack = this.pushLeakingStack();
+
+        this._leakWarnCountdown -= 1;
+        if (this._leakWarnCountdown <= 0) {
+            // only warn on first exceed and then every time the limit
+            // is exceeded by 50% again
+            this._leakWarnCountdown = maxListeners * 0.5;
+
+            let topStack: string;
+            let topCount = 0;
+            this._leakingStacks!.forEach((stackCount, stack) => {
+                if (!topStack || topCount < stackCount) {
+                    topStack = stack;
+                    topCount = stackCount;
+                }
+            });
+
+            // eslint-disable-next-line max-len
+            console.warn(`Possible Emitter memory leak detected. ${listenerCount} listeners added. Use event.maxListeners to increase the limit (${maxListeners}). MOST frequent listener (${topCount}):`);
+            console.warn(topStack!);
+        }
+
+        return popStack;
+    }
+
+    protected pushLeakingStack(): () => void {
+        if (!this._leakingStacks) {
+            this._leakingStacks = new Map();
+        }
+        const stack = new Error().stack!.split('\n').slice(3).join('\n');
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count + 1);
+        return () => this.popLeakingStack(stack);
+    }
+
+    protected popLeakingStack(stack: string): void {
+        if (!this._leakingStacks) {
+            return;
+        }
+        const count = (this._leakingStacks.get(stack) || 0);
+        this._leakingStacks.set(stack, count - 1);
+    }
+
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event: T): any {
+        if (this._callbacks) {
+            this._callbacks.invoke(event);
+        }
+    }
+
+    /**
+     * Process each listener one by one.
+     * Return `false` to stop iterating over the listeners, `true` to continue.
+     */
+    async sequence(processor: (listener: (e: T) => any) => MaybePromise<boolean>): Promise<void> {
+        if (this._callbacks) {
+            for (const listener of this._callbacks) {
+                if (!await processor(listener)) {
+                    break;
+                }
+            }
+        }
+    }
+
+    dispose(): void {
+        if (this._leakingStacks) {
+            this._leakingStacks.clear();
+            this._leakingStacks = undefined;
+        }
+        if (this._callbacks) {
+            this._callbacks.dispose();
+            this._callbacks = undefined;
+        }
+        this._disposed = true;
+    }
+}
+
+export interface WaitUntilEvent {
+    /* eslint-disable @typescript-eslint/no-explicit-any */
+    /**
+     * Allows to pause the event loop until the provided thenable resolved.
+     *
+     * *Note:* It can only be called during event dispatch and not in an asynchronous manner
+     *
+     * @param thenable A thenable that delays execution.
+     */
+    waitUntil(thenable: Promise<any>): void;
+    /* eslint-enable @typescript-eslint/no-explicit-any */
+}
+export namespace WaitUntilEvent {
+    export async function fire<T extends WaitUntilEvent>(
+        emitter: Emitter<T>,
+        event: Pick<T, Exclude<keyof T, 'waitUntil'>>,
+        timeout: number | undefined = undefined
+    ): Promise<void> {
+        const waitables: Promise<void>[] = [];
+        const asyncEvent = Object.assign(event, {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            waitUntil: (thenable: Promise<any>) => {
+                if (Object.isFrozen(waitables)) {
+                    throw new Error('waitUntil cannot be called asynchronously.');
+                }
+                waitables.push(thenable);
+            }
+        }) as T;
+        try {
+            emitter.fire(asyncEvent);
+            // Asynchronous calls to `waitUntil` should fail.
+            Object.freeze(waitables);
+        } finally {
+            delete asyncEvent['waitUntil'];
+        }
+        if (!waitables.length) {
+            return;
+        }
+        if (timeout !== undefined) {
+            await Promise.race([Promise.all(waitables), new Promise(resolve => setTimeout(resolve, timeout))]);
+        } else {
+            await Promise.all(waitables);
+        }
+    }
+}

package/lib/tools/codegen/templates/common/src/core/index.ts.template

@@ -0,0 +1,3 @@
+export * from './disposable';
+export * from './event';
+export * from './types';

package/lib/tools/codegen/templates/common/src/core/types.ts.template

@@ -0,0 +1 @@
+export type MaybePromise<T> = T | PromiseLike<T>;

package/lib/tools/codegen/templates/common/src/generated/service-schemas.ts.template

@@ -0,0 +1 @@
+export const DUMMY2 = 'dummy';

package/lib/tools/codegen/templates/common/src/index.server.ts.template

@@ -0,0 +1,7 @@
+export * from './generated/generated-models';
+export * from './generated/service-schemas';
+export * from './configuration';
+export * from './permissions';
+export * from './apollo-context';
+export * from './types';
+export * from './core';

package/lib/tools/codegen/templates/common/src/index.ts.template

@@ -3,3 +3,4 @@ export * from './configuration';
 export * from './permissions';
 export * from './apollo-context';
 export * from './types';
+export * from './core';

package/lib/utils/index.d.ts

@@ -1,4 +1,5 @@
 export * from './utils';
+export * from './packageUtils';
 export * from './withErrorHandleUtil';
 export * from './setupConfig';
 export * from './verifyConfig';