restfuncs-transformer 0.9.8 → 1.1.0

package/AddRemoteMethodsMeta.ts

@@ -0,0 +1,481 @@
+import ts, {
+    ArrowFunction,
+    ClassDeclaration, Expression, FunctionTypeNode, Identifier,
+    MethodDeclaration,
+    Node, NodeArray,
+    ObjectLiteralExpression, ParameterDeclaration,
+    PropertyAccessExpression,
+    SyntaxKind, TypeNode, TypeReference, TypeReferenceNode
+} from 'typescript';
+import {FileTransformRun, TextPatch} from "./transformerUtil";
+import {transformerVersion} from "./index";
+import {visitReplace} from "restfuncs-common";
+
+
+/**
+ * Transformer that adds the following statement to the method body (like in readme.md#how-it-works)
+ * <code><pre>
+ * static getRemoteMethodsMeta() {
+ *     ....
+ * }
+ * </pre></code>
+ */
+export class AddRemoteMethodsMeta extends FileTransformRun {
+    /**
+     * Should this transformer squeeze the added declarations (result) into one line to keep the line numbers in the source text intact ?
+     * Prevents the [broken source maps bug](https://github.com/bogeeee/restfuncs/issues/2)
+     */
+    static squeezeDeclarationsIntoOneLine = true;
+    diagnosis_currentClass_instanceMethodsSeen?: Set<string>;
+    currentClass_instanceMethodsMeta?: Record<string, string>; // The {...} that should be added below... see example in readme.md
+    result = new TextPatch();
+
+    /* Visitor Function */
+    visit(node: Node): Node {
+        if (node.kind === SyntaxKind.MethodDeclaration) { // @remote ?
+            const methodDeclaration = (node as MethodDeclaration)
+            if(this.getChilds(methodDeclaration).some(n => n.kind == SyntaxKind.StaticKeyword)) { // static ?
+                return node; // no special handling
+            }
+            if(this.getParent().kind !== SyntaxKind.ClassDeclaration) { // Method not under a class (i.e. an anonymous object ?}
+                return node; // no special handling
+            }
+
+            const methodName = (methodDeclaration.name as any).escapedText;
+            try {
+                let remoteDecorator = this.getChilds(methodDeclaration).find(d => d.kind === SyntaxKind.Decorator);
+                if (!remoteDecorator) { // no @remote found ?
+                    return node; // no special handling
+                }
+
+                // Diagnosis: Check for overloads:
+                if(this.diagnosis_currentClass_instanceMethodsSeen?.has(methodName)) { // Seen twice ?
+                    throw new Error(`@remote methods cannot have multiple/overloaded signatures: ${methodName}. Location: ${this.diag_sourceLocation(node)}`) // TODO: add diagnosis
+                }
+
+                this.currentClass_instanceMethodsMeta![methodName] = this.createMethodMetaExpression(methodDeclaration, methodName) // create the code:
+            }
+            finally {
+                this.diagnosis_currentClass_instanceMethodsSeen!.add(methodName);
+            }
+
+            return node;
+        }
+        else if(node.kind === SyntaxKind.ClassDeclaration) {
+            this.diagnosis_currentClass_instanceMethodsSeen = new Set()
+            this.currentClass_instanceMethodsMeta = {}
+            try {
+                let result = this.visitChilds(node) as ClassDeclaration
+
+                if(Object.keys(this.currentClass_instanceMethodsMeta).length > 0) { // Current class has @remote methods ?
+                    if(this.result.patches.length === 0) { // First patch
+                        this.result.patches.push({position: 0, contentToInsert: '/* inserted by restfuncs-transformer:*/import _rf_typia from "typia";'}); // add the type import, which is needed by the following
+                    }
+
+                    // *** Create the "getRemoteMethodsMeta()" function and add a patch for the source file to the result: ***
+                    let methodDeclarationSourceText = this.create_static_getRemoteMethodsMeta_expression();
+                    if(AddRemoteMethodsMeta.squeezeDeclarationsIntoOneLine) {
+                        methodDeclarationSourceText = '/* code squeezed into one line to keep line numbers intact. You can output it prettier by setting "pretty":true in the plugin configuration in tsconfig.json */' + methodDeclarationSourceText.replaceAll("\n","");
+                    }
+                    methodDeclarationSourceText = ";" + methodDeclarationSourceText; // prepend with semicolon to prevent syntax error if there's stuff in the same line of the closing bracket
+
+                    this.result.patches.push({position: node.end -1 /* insert before the closing bracket*/, contentToInsert: methodDeclarationSourceText}); // Add patch to result
+                }
+
+
+                return result
+            }
+            finally {
+                this.currentClass_instanceMethodsMeta = undefined
+                this.diagnosis_currentClass_instanceMethodsSeen = undefined
+            }
+        }
+        else {
+            return this.visitChilds(node);
+        }
+    }
+
+
+    /**
+     * Crates the following expression like in readme.md#how-it-works
+     * <code><pre>
+     * {
+     *     arguments: {
+     *        ...
+     *     }
+     *     result: {
+     *         ...
+     *     }
+     *     callbacks:[...]
+     *     jsDoc: {
+     *         ...
+     *     }
+     * }
+     * </pre></code>
+     *
+     * @param methodName
+     * @private
+     */
+    createMethodMetaExpression(node: MethodDeclaration, methodName: string): string {
+        // Note: These `factory.create...` "pyramids of doom", which you see all along in this method's code, were mostly created by copying the example code from readme.md#how-it-works through the [AST viewer tool](https://ts-ast-viewer.com/)
+        // TODO: remove them und use plain strings
+        const factory = this.context.factory;
+
+        const arguments_typiaFuncs:Record<string, string> = {
+            "validateEquals": "_rf_typia.validateEquals",
+            "validatePrune": "_rf_typia.misc.validatePrune"
+        }
+        const result_typiaFuncs = {...arguments_typiaFuncs};
+
+        const old_typiaFuncs:Record<string, PropertyAccessExpression> = {
+            /**
+             * typia.validateEquals
+             */
+            validateEquals: factory.createPropertyAccessExpression(
+                factory.createIdentifier("_rf_typia"),
+                factory.createIdentifier("validateEquals")
+            ),
+            "validatePrune": factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(
+                factory.createIdentifier("_rf_typia"),
+                factory.createIdentifier("misc")
+            ), factory.createIdentifier("validatePrune"))
+        }
+
+        // Clone parameters and convert all ParameterDeclarations to NamedTupleMembers (They look the same in the .ts code but are of a different SyntaxKind).
+        const methodParametersWithPlaceholders = structuredClone(node.parameters).map(paramDecl => {
+            return factory.createNamedTupleMember(
+                paramDecl.dotDotDotToken,
+                paramDecl.name as Identifier,
+                paramDecl.questionToken,
+                paramDecl.type || factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
+            )
+        });
+
+        // ** Callbacks: **
+        // Replace the (arrow-) function declarations inside methodParametersWithPlaceholders with "_callback" placeholders and create the callbackDeclarations array which contains the
+        // declarations like in readme.md saying "[{ // here for the `someCallbackFn: (p:number) => Promise<string>` declaration ...}]"
+        let callbackDeclarations: ObjectLiteralExpression[] = [];
+        visitReplace(methodParametersWithPlaceholders, (value, visitChilds, context) => {
+            if (value && (value as Node).kind === SyntaxKind.FunctionType) { // found an arrow-style function type declaration ?
+                const functionTypeNode = value as FunctionTypeNode;
+                // **** Create the callbackDeclaration like `{ // here for the `someCallbackFn: (p:number) => Promise<string>` declaration...}` in readme.md ****
+                // Create argumentsDeclaration. `{ validateEquals: ..., validatePrune: ...}` like in readme.md
+                const argumentsDeclaration = factory.createObjectLiteralExpression(
+                    Object.keys(arguments_typiaFuncs).map((typiaFnName) => // for validateEquals + validatePrune
+                        factory.createPropertyAssignment(
+                            factory.createIdentifier(typiaFnName),
+                            factory.createArrowFunction(
+                                undefined,
+                                undefined,
+                                [factory.createParameterDeclaration(
+                                    undefined,
+                                    undefined,
+                                    factory.createIdentifier("args"),
+                                    undefined,
+                                    factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+                                    undefined
+                                )],
+                                undefined,
+                                factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+                                factory.createCallExpression(old_typiaFuncs[typiaFnName],
+                                    [factory.createTupleTypeNode(structuredClone(functionTypeNode.parameters).map(paramDecl => { // Must convert ParameterDeclarations to NamedTupleMembers (They look the same in the .ts code but are of a different SyntaxKind).
+                                        return factory.createNamedTupleMember(
+                                            paramDecl.dotDotDotToken,
+                                            paramDecl.name as Identifier,
+                                            paramDecl.questionToken,
+                                            paramDecl.type || factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword)
+                                        )
+                                    }))],
+                                    [factory.createIdentifier("args")]
+                                )
+                            )
+                        )),
+                    true
+                );
+                // Create awaitedResultDeclaration. `awaitedResult = ...` like in readme.md:
+                let awaitedResultDeclaration: Expression;
+                if (functionTypeNode.type.kind == SyntaxKind.VoidKeyword) { // Return type is (sync) void ?
+                    awaitedResultDeclaration = factory.createIdentifier("undefined");
+                } else {
+                    if (functionTypeNode.type.kind == SyntaxKind.TypeReference && ((functionTypeNode.type as TypeReferenceNode).typeName as any).escapedText == "Promise") { // Returns via Promise
+                        // Validity check:
+                        if (!(functionTypeNode.type as TypeReferenceNode).typeArguments || (functionTypeNode.type as TypeReferenceNode).typeArguments!.length != 1) {
+                            throw new Error(`A callback function, declared in ${methodName}'s parameters, returns a Promise with an invalid number of type arguments. Location: ${this.diag_sourceLocation(node)}`);
+                        }
+
+                        const awaitedType: TypeReferenceNode = (functionTypeNode.type as TypeReferenceNode).typeArguments![0] as TypeReferenceNode;
+
+                        awaitedResultDeclaration = factory.createObjectLiteralExpression(
+                            Object.keys(result_typiaFuncs).map((typiaFnName) => // for validateEquals + validatePrune
+                                factory.createPropertyAssignment(
+                                    factory.createIdentifier(typiaFnName),
+                                    factory.createArrowFunction(
+                                        undefined,
+                                        undefined,
+                                        [factory.createParameterDeclaration(
+                                            undefined,
+                                            undefined,
+                                            factory.createIdentifier("value"),
+                                            undefined,
+                                            factory.createKeywordTypeNode(ts.SyntaxKind.UnknownKeyword),
+                                            undefined
+                                        )],
+                                        undefined,
+                                        factory.createToken(ts.SyntaxKind.EqualsGreaterThanToken),
+                                        factory.createCallExpression(old_typiaFuncs[typiaFnName],
+                                            [awaitedType],
+                                            [factory.createIdentifier("value")]
+                                        )
+                                    )
+                                )),
+                            true
+                        );
+                    } else {
+                        throw new Error(`A callback function, declared in ${methodName}'s parameters, declares that it returns a value directly (sync) and not via Promise (this is not possible over the wire). Please use Promise<${this.nodeToString(functionTypeNode.type, true, true)}> instead. Location: ${this.diag_sourceLocation(functionTypeNode.type)}`);
+                    }
+                }
+
+                // Compose result:
+                const callbackDeclaration = factory.createObjectLiteralExpression(
+                    [
+                        // arguments: {...}
+                        factory.createPropertyAssignment(
+                            factory.createIdentifier("arguments"),
+                            argumentsDeclaration
+                        ),
+
+                        // awaitedResult: {...}
+                        factory.createPropertyAssignment(
+                            factory.createIdentifier("awaitedResult"),
+                            awaitedResultDeclaration
+                        ),
+                        // source:
+                        factory.createPropertyAssignment(
+                            factory.createIdentifier("diagnosis_source"), this.createSourceNodeDiagnosisExpression(functionTypeNode)
+                        )
+                    ],
+                    true
+                );
+
+                callbackDeclarations.push(callbackDeclaration);
+                const declarationIndex = callbackDeclarations.length -1;
+                return factory.createExpressionWithTypeArguments(factory.createIdentifier("CallbackPlaceholder"),[factory.createLiteralTypeNode(factory.createNumericLiteral(declarationIndex))]); // replace with CallbackPlaceholder<n>
+            }
+            return visitChilds(value, context)
+        });
+
+        // ** Obtain, what goes into typia.validate...<...> ***
+        const hasPlaceholders = callbackDeclarations.length > 0;
+        let typeParamForTypiaValidate = `[${node.parameters.map(param => this.nodeToString(param, true, true)).join(", ")}]`; // [param1: type1, param2: type2, ...]
+        let typeParamForTypiaValidateWithPlaceholders: string = this.nodeToString(factory.createTupleTypeNode(methodParametersWithPlaceholders),true, true);
+
+
+        if (node.parameters.some(p => p.type === undefined)) { // Some parameters don't have an explicit type ? (i.e. the type is inherited from the base class)
+            if (hasPlaceholders) {
+                throw new Error(`Parameter '${(node.parameters.find(p => p.type === undefined) as any)!.name.escapedText}' does not have a (/ an explicit) type in remote method ${methodName}. In combination with declared callback functions, all parameters must have explicit types. Location: ${this.diag_sourceLocation(node)}`) // TODO: add diagnosis
+            }
+            // Use the old style: Parameters<typeof this.prototype["method name"]>. This worked very fine in old versions but we now want to battle-test the other style
+            typeParamForTypiaValidate = typeParamForTypiaValidateWithPlaceholders = `Parameters<typeof this.prototype["${methodName}"]>`;
+        }
+
+        // ** compose result **
+        return `{
+                            arguments: {${/* for validateEquals + validatePrune */ Object.keys(arguments_typiaFuncs).map((typiaFnName) => `
+                                ${typiaFnName}: (args: unknown) => ${arguments_typiaFuncs[typiaFnName]}<${typeParamForTypiaValidate}>(args)`).join(",")}
+                                ,
+                                withPlaceholders: ${hasPlaceholders?`{${/* for validateEquals + validatePrune */ Object.keys(arguments_typiaFuncs).map((typiaFnName) => `
+                                    ${typiaFnName}: (args: unknown, onValidateCallbackArg: (placeholderId: string, declarationIndex: number) => boolean) => ${arguments_typiaFuncs[typiaFnName]}<${typeParamForTypiaValidateWithPlaceholders}>(args)`).join(",")}                                    
+                                }`:"undefined"}
+                            },
+                            result: {${/* for validateEquals + validatePrune */ Object.keys(result_typiaFuncs).map((typiaFnName) => `
+                                ${typiaFnName}: (value: unknown) => ${result_typiaFuncs[typiaFnName]}<Awaited<ReturnType<typeof this.prototype["${methodName}"]>>>(value)`).join(",")}
+                            },
+                            callbacks: [${callbackDeclarations.map(cbd => `
+                                ${this.nodeToString(cbd, true)}`).join(",")}
+                            ],
+                            jsDoc: ${this.nodeToString(this.createJsDocExpression(node, methodName), true)},
+                            diagnosis_source: ${this.nodeToString(this.createSourceNodeDiagnosisExpression(node), true)},
+                        }`;
+    }
+
+    /**
+     * Crates the following expression like in readme.md#how-it-works
+     * <code><pre>
+     * {
+     *     comment: "...",
+     *     params: {...},
+     *     ...
+     * }
+     * </pre></code>
+     *
+     * or
+     *
+     * <code><pre>
+     *     undefined
+     * </pre></code>
+     *
+     *
+     * @param methodName
+     * @private
+     */
+    private createJsDocExpression(node: MethodDeclaration, diagnosis_methodName: string) {
+        const factory = this.context.factory;
+
+        if(!node.jsDoc || node.jsDoc.length == 0 ) { // no jsdoc
+            return factory.createIdentifier("undefined");
+        }
+
+        const jsdoc = node.jsDoc[node.jsDoc.length - 1]; // use last jsDoc
+
+        const comment = jsdoc.comment || "";
+        if(typeof comment !== "string") {
+            throw new Error(`Expected comment to be a string. Got: ${comment}. Location: ${this.diag_sourceLocation(node)}`); // TODO add to diagnostics instead
+        }
+
+        // Collect params and tags
+        const params: Record<string, string> = {}
+        const tags: {name:string, comment?: string}[] = []
+        jsdoc.tags?.forEach(tag => {
+            const name = (tag.tagName.escapedText as string).toLowerCase()
+            const comment = tag.comment;
+            if(comment && typeof comment !== "string") {
+                throw new Error(`Expected comment to be a string. Got: ${comment}. Location: ${this.diag_sourceLocation(node)}` ); // TODO add to diagnostics instead
+            }
+
+            if(name === "param") {
+                const paramname = (tag as any).name?.escapedText;
+                if(paramname && comment) {
+                    params[paramname] = comment;
+                }
+            }
+            else {
+                const tagName: Node | undefined = (tag as any).name;
+                tags.push({name, comment})
+            }
+        })
+
+        // JSDoc. Example from readme.md#how-it-works Copy&pasted through the [AST viewer tool](https://ts-ast-viewer.com/)
+        let jsDocExpression = factory.createObjectLiteralExpression(
+            [
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("comment"),
+                    factory.createStringLiteral(comment)
+                ),
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("params"),
+                    factory.createObjectLiteralExpression(
+                        Object.keys(params).map(paramName =>
+                            factory.createPropertyAssignment(
+                            factory.createIdentifier(paramName),
+                            factory.createStringLiteral(params[paramName])
+                        )),
+                        false
+                    )
+                ),
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("tags"),
+                    factory.createArrayLiteralExpression(
+                         tags.map(tag => factory.createObjectLiteralExpression(
+                            [
+                                factory.createPropertyAssignment(
+                                    factory.createIdentifier("name"),
+                                    factory.createStringLiteral(tag.name)
+                                ),
+                                factory.createPropertyAssignment(
+                                    factory.createIdentifier("comment"),
+                                    tag.comment !== undefined?factory.createStringLiteral(tag.comment):factory.createIdentifier("undefined")
+                                )
+                            ],
+                            false
+                        )),
+                        false
+                    )
+                )
+            ],
+            true
+        )
+        return jsDocExpression;
+    }
+
+    /**
+     * Crates the following expression like in readme.md#how-it-works
+     * <code><pre>
+     * static getRemoteMethodsMeta(...) :... {
+     *     ....
+     * }
+     * </pre></code>
+     *
+     * @param methodName
+     * @private
+     */
+    private create_static_getRemoteMethodsMeta_expression() : string {
+        return `` +
+            `static getRemoteMethodsMeta(): (typeof this.type_remoteMethodsMeta) {
+                this.__hello_developer__make_sure_your_class_is_a_subclass_of_ServerSession;` /* Attempt to give a friendly error message when this is not the case. Otherwise the previous line would fail and leaves the user wondering. */ + `
+                type CallbackPlaceholder<DECL_INDEX extends number>  = string & _rf_typia.tags.TagBase<{kind: "callbackFn", target: "string", value: undefined, validate: \`onValidateCallbackArg($input, \${DECL_INDEX})\`}>;
+                const result= {
+                    transformerVersion: {major: ${transformerVersion.major},  feature: ${transformerVersion.feature} },
+                    instanceMethods: {${Object.keys(this.currentClass_instanceMethodsMeta!).map(methodName => `
+                        ${methodName}: ${this.currentClass_instanceMethodsMeta![methodName]}`).join(",")}
+                    }
+                };
+        
+                return result; /* Code style note for this line: Why not do \`return {...}\` directly ? This tiny difference allows for extra properties which ensure backward compatibility with older "restfuncs-server" packages. */
+            }`
+    }
+
+    nodeToString(node: Node, removeComments= false, removeLineBreaks = false): string {
+        const printer = ts.createPrinter({ newLine: ts.NewLineKind.LineFeed, removeComments});
+        let result = printer.printNode(ts.EmitHint.Unspecified, node, this.sourceFile) as string;
+        if(removeLineBreaks) {
+            result = result.replaceAll(/\n\s*/g," ")
+        }
+        return  result;
+    }
+
+    /**
+     * Creates a node, that declares a SourceNodeDiagnosis (defined in ServerSession.ts) object.
+     *
+     * To output the info at runtime: i.e. "MyServerSessionClass.ts:23:30, reading: async myRemoteMethod(param1:...): Promise<void> {}
+     * @param node
+     */
+    createSourceNodeDiagnosisExpression(node: Node) {
+        const factory = this.context.factory;
+        if((node as any).body !== undefined) {
+            // Empty the body
+            node = structuredClone(node);
+            (node as any).body = factory.createBlock([],false);
+        }
+
+        const lineAndChar = this.sourceFile.getLineAndCharacterOfPosition((node.getStart?.(this.sourceFile, false) || node.pos));
+
+
+        return factory.createObjectLiteralExpression(
+            [
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("file"),
+                    factory.createStringLiteral(this.sourceFile.fileName)
+                ),
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("line"),
+                    factory.createNumericLiteral(lineAndChar.line + 1)
+                ),
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("character"),
+                    factory.createNumericLiteral(lineAndChar.character + 1)
+                ),
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("signatureText"),
+                    factory.createStringLiteral(this.nodeToString(node, false))
+                )
+            ],
+            false
+        )
+
+    }
+
+    diag_sourceLocation(node: Node) {
+        const lineAndChar = this.sourceFile.getLineAndCharacterOfPosition((node.getStart?.(this.sourceFile, false) || node.pos));
+        return `${this.sourceFile.fileName}:${lineAndChar.line+1}:${lineAndChar.character+1}`
+    }
+}

package/devPlayground.d.ts

@@ -0,0 +1,3 @@
+type paramsLikeInFn = [a: string, b: number, ...restOfArgs: string[]];
+declare const f: paramsLikeInFn;
+//# sourceMappingURL=devPlayground.d.ts.map

package/devPlayground.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"devPlayground.d.ts","sourceRoot":"","sources":["devPlayground.ts"],"names":[],"mappings":"AAAA,KAAK,cAAc,GAAG,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,GAAG,UAAU,EAAE,MAAM,EAAE,CAAC,CAAC;AAGtE,QAAA,MAAM,CAAC,EAAE,cAAiC,CAAC"}

package/devPlayground.js

@@ -0,0 +1,3 @@
+"use strict";
+const f = ["", 123, "", ""];
+//# sourceMappingURL=devPlayground.js.map

package/devPlayground.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devPlayground.js","sourceRoot":"","sources":["devPlayground.ts"],"names":[],"mappings":";AAGA,MAAM,CAAC,GAAmB,CAAC,EAAE,EAAE,GAAG,EAAE,EAAE,EAAC,EAAE,CAAC,CAAC"}

package/devPlayground.ts

@@ -0,0 +1,5 @@
+type paramsLikeInFn = [a: string, b: number, ...restOfArgs: string[]];
+
+
+const f: paramsLikeInFn = ["", 123, "",""];
+

package/index.d.ts

@@ -1,3 +1,8 @@
-import transformer from "typescript-rtti/dist/transformer";
-export default transformer;
+import { CompilerHost, Program } from 'typescript';
+import { PluginConfig, ProgramTransformerExtras } from "ts-patch";
+export declare const transformerVersion: {
+    major: number;
+    feature: number;
+};
+export default function transformProgram(program: Program, host: CompilerHost | undefined, config: PluginConfig, extras?: ProgramTransformerExtras): Program;
 //# sourceMappingURL=index.d.ts.map

package/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAEA,OAAO,WAAW,MAAM,kCAAkC,CAAC;AAC3D,eAAe,WAAW,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAAA,OAAW,EAAC,YAAY,EAAmB,OAAO,EAAa,MAAM,YAAY,CAAC;AAClF,OAAO,EAAC,YAAY,EAAE,wBAAwB,EAAC,MAAM,UAAU,CAAC;AAOhE,eAAO,MAAM,kBAAkB;;;CAA2B,CAAA;AAwC1D,MAAM,CAAC,OAAO,UAAU,gBAAgB,CACpC,OAAO,EAAE,OAAO,EAChB,IAAI,EAAE,YAAY,GAAG,SAAS,EAC9B,MAAM,EAAE,YAAY,EACpB,MAAM,CAAC,EAAE,wBAAwB,GAClC,OAAO,CAiDT"}

package/index.js

@@ -1,33 +1,98 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const __RΦ = { m: (k, v) => (t, ...a) => t && Reflect.metadata ? Reflect.metadata(k, v)(t, ...a) : void 0, f: (f, d, n) => (d.forEach(d => d(f)), Object.defineProperty(f, "name", { value: n, writable: false }), f), c: (c, d, dp, dsp, n) => (d.forEach(d => d(c)), dp.forEach(([p, d]) => d(c.prototype, p)), dsp.forEach(([p, d]) => d(c, p)), n ? Object.defineProperty(c, "name", { value: n, writable: false }) : undefined, c), r: (o, a) => (Object.assign(o, a)), a: id => {
-        let t = __RΦ.t[id];
-        if (t === void 0)
-            return void 0;
-        if (t.RΦ) {
-            let r = t.RΦ;
-            delete t.RΦ;
-            __RΦ.r(t, r(t));
+exports.transformerVersion = void 0;
+const AddRemoteMethodsMeta_1 = require("./AddRemoteMethodsMeta");
+const transformerUtil_1 = require("./transformerUtil");
+const fs = __importStar(require("node:fs"));
+// From: https://github.com/nonara/ts-patch/discussions/29#discussioncomment-325979
+exports.transformerVersion = { major: 1, feature: 2 };
+/* ****************************************************************************************************************** */
+// region: Helpers
+/* ****************************************************************************************************************** */
+/**
+ * Patches existing Compiler Host (or creates new one) to allow feeding updated file content from cache
+ */
+function getPatchedHost(maybeHost, tsInstance, compilerOptions) {
+    const fileCache = new Map();
+    const compilerHost = maybeHost !== null && maybeHost !== void 0 ? maybeHost : tsInstance.createCompilerHost(compilerOptions, true);
+    const originalGetSourceFile = compilerHost.getSourceFile;
+    return Object.assign(compilerHost, {
+        getSourceFile(fileName, languageVersion) {
+            fileName = tsInstance.normalizePath(fileName);
+            if (fileCache.has(fileName))
+                return fileCache.get(fileName);
+            const sourceFile = originalGetSourceFile.apply(void 0, Array.from(arguments));
+            fileCache.set(fileName, sourceFile);
+            return sourceFile;
+        },
+        fileCache
+    });
+}
+// endregion
+/* ****************************************************************************************************************** */
+// region: Program Transformer
+/* ****************************************************************************************************************** */
+function transformProgram(program, host, config, extras) {
+    if (!extras) {
+        throw new Error(`Please add the flag "transformProgram": true to the transformer inside tsconfig.json`);
+    }
+    const { ts: tsInstance } = extras;
+    const compilerOptions = program.getCompilerOptions();
+    const compilerHost = getPatchedHost(host, tsInstance, compilerOptions);
+    const rootFileNames = program.getRootFileNames().map(tsInstance.normalizePath);
+    const transformerFactoryOOP = new transformerUtil_1.TransformerFactoryOOP(AddRemoteMethodsMeta_1.AddRemoteMethodsMeta);
+    AddRemoteMethodsMeta_1.AddRemoteMethodsMeta.squeezeDeclarationsIntoOneLine = !(config.pretty);
+    // TODO: Do we still need all this transformer stuff or can we throw that out and use a simple file vistor ? Cause we don't actually **transform** a SourceFile anymore, but just patch text content and not an AST.
+    /* Transform AST */
+    tsInstance.transform(
+    /* sourceFiles */ program.getSourceFiles().filter(sourceFile => rootFileNames.includes(sourceFile.fileName) && !sourceFile.fileName.includes("after_restfuncs-transformer")), 
+    /* transformerFactoryOOP */ [transformerFactoryOOP.asFunction], compilerOptions);
+    transformerFactoryOOP.transformRunsDone.forEach(transformRun => {
+        if (transformRun.result.patches.length > 0) { // wants to make changes to the file ?
+            /* Render modified files and create new SourceFiles for them to use in host's cache */
+            const sourceFile = transformRun.sourceFile;
+            const sourceText = fs.readFileSync(sourceFile.fileName, { encoding: "utf8" });
+            const patchedSourceText = transformRun.result.applyPatches(sourceText);
+            if (config.debug) {
+                // Write content to file so you can better inspect it.
+                const newFileName = sourceFile.fileName.replace(/\.ts$/, ".after_restfuncs-transformer.tmp");
+                if (newFileName === sourceFile.fileName) {
+                    throw new Error("invalid file name");
+                }
+                fs.writeFileSync(newFileName, patchedSourceText, { encoding: "utf8" });
+            }
+            // Insert patchedSourceText into host's cache:
+            const newSourceFile = tsInstance.createSourceFile(sourceFile.fileName, patchedSourceText, sourceFile.languageVersion);
+            newSourceFile.version = `${sourceFile.version}_restfuncs_${exports.transformerVersion.major}.${exports.transformerVersion.feature}`;
+            compilerHost.fileCache.set(sourceFile.fileName, newSourceFile);
         }
-        else if (t.LΦ) {
-            let l = t.LΦ();
-            delete t.LΦ;
-            __RΦ.t[id] = t = l;
-        }
-        return t;
-    }, oe: (o, k) => {
-        try {
-            return o[k];
-        }
-        catch (e) {
-            return undefined;
-        }
-    }, t: {} };
-// Just pass-through the default export of typescript-rtti/dist/transformer
-// May be later, we need to extend the transformer for runtime inspection JSDoc information
-const transformer_1 = __importDefault(require("typescript-rtti/dist/transformer"));
-exports.default = transformer_1.default;
+    });
+    /* Re-create Program instance */
+    return tsInstance.createProgram(rootFileNames, compilerOptions, compilerHost);
+}
+exports.default = transformProgram;
+// endregion
 //# sourceMappingURL=index.js.map

package/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,2EAA2E;AAC3E,2FAA2F;AAC3F,mFAA2D;AAC3D,kBAAe,qBAAW,CAAA"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"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"}