restfuncs-transformer 0.9.8 → 1.0.0

package/AddRemoteMethodsMeta.ts

@@ -0,0 +1,403 @@
+import ts, {
+    ClassDeclaration,
+    MethodDeclaration,
+    Node,
+    ObjectLiteralExpression,
+    PropertyAccessExpression,
+    SyntaxKind
+} from 'typescript';
+import {FileTransformRun} from "./transformerUtil";
+import {transformerVersion} from "./index";
+
+
+/**
+ * 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 {
+
+    diagnosis_currentClass_instanceMethodsSeen?: Set<string>;
+    currentClass_instanceMethodsMeta?: Record<string, ObjectLiteralExpression>; // The {...} that should be added below... see example in readme.md
+    astWasModified = false;
+
+    /* 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;
+            }
+            if(this.getParent().kind !== SyntaxKind.ClassDeclaration) { // Method not under a class (i.e. an anonymous object ?}
+                return node;
+            }
+
+            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;
+                }
+
+                // Diagnosis: Check for overloads:
+                if(this.diagnosis_currentClass_instanceMethodsSeen?.has(methodName)) { // Seen twice ?
+                    throw new Error(`@remote methods cannot have multiple/overloaded signatures: ${methodName}`) // 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 ?
+                    // add "static getRemoteMethodsMeta() {...}" method:
+                    // @ts-ignore yes, a bit hacky, but with factory.crateClassDeclation we might also miss some properties
+                    result.members = this.context.factory.createNodeArray([...result.members.values(), this.create_static_getRemoteMethodsMeta_expression()])
+                    this.astWasModified = true;
+                }
+
+
+                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: {
+     *        ...
+     *     }
+     *     jsDoc: {
+     *         ...
+     *     }
+     * }
+     * </pre></code>
+     *
+     * @param methodName
+     * @private
+     */
+    createMethodMetaExpression(node: MethodDeclaration, methodName: string) {
+        const factory = this.context.factory;
+
+        const arguments_typiaFuncs:Record<string, PropertyAccessExpression> = {
+            /**
+             * typia.validateEquals
+             */
+            validateEquals: factory.createPropertyAccessExpression(
+                factory.createIdentifier("typia"),
+                factory.createIdentifier("validateEquals")
+            ),
+            "validatePrune": factory.createPropertyAccessExpression(factory.createPropertyAccessExpression(
+                factory.createIdentifier("typia"),
+                factory.createIdentifier("misc")
+            ), factory.createIdentifier("validatePrune"))
+        }
+        const result_typiaFuncs = {...arguments_typiaFuncs};
+
+        // Example from readme.md#how-it-works Copy&pasted through the [AST viewer tool](https://ts-ast-viewer.com/)
+        // @ts-ignore
+        return factory.createObjectLiteralExpression(
+            [
+                // arguments: {...}
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("arguments"),
+                    factory.createObjectLiteralExpression(
+                        Object.keys(arguments_typiaFuncs).map((typiaFnName) =>
+                        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(arguments_typiaFuncs[typiaFnName],
+                                    [factory.createTypeReferenceNode(
+                                        factory.createIdentifier("Parameters"),
+                                        [factory.createIndexedAccessTypeNode(
+                                            factory.createTypeQueryNode(
+                                                factory.createQualifiedName(
+                                                    factory.createIdentifier("this"),
+                                                    factory.createIdentifier("prototype")
+                                                ),
+                                                undefined
+                                            ),
+                                            factory.createLiteralTypeNode(factory.createStringLiteral(methodName))
+                                        )]
+                                    )],
+                                    [factory.createIdentifier("args")]
+                                )
+                            )
+                        )),
+                        true
+                    )
+                ),
+                // result: {...}
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("result"),
+                    factory.createObjectLiteralExpression(
+                        Object.keys(result_typiaFuncs).map((typiaFnName) =>
+                            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(arguments_typiaFuncs[typiaFnName],
+                                        [factory.createTypeReferenceNode(
+                                            factory.createIdentifier("Awaited"), [factory.createTypeReferenceNode(
+                                                factory.createIdentifier("ReturnType"),
+                                                [factory.createIndexedAccessTypeNode(
+                                                    factory.createTypeQueryNode(
+                                                        factory.createQualifiedName(
+                                                            factory.createIdentifier("this"),
+                                                            factory.createIdentifier("prototype")
+                                                        ),
+                                                        undefined
+                                                    ),
+                                                    factory.createLiteralTypeNode(factory.createStringLiteral(methodName))
+                                                )]
+                                            )]
+                                        )],
+                                        [factory.createIdentifier("value")]
+                                    )
+                                )
+                            )),
+                        true
+                    )
+                ),
+                factory.createPropertyAssignment(
+                    factory.createIdentifier("jsDoc"), this.createJsDocExpression(node, methodName)
+                )
+            ],
+            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}` ); // 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}` ); // 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() : MethodDeclaration {
+        const factory = this.context.factory;
+
+
+        let instanceMethods = factory.createObjectLiteralExpression(
+            Object.keys(this.currentClass_instanceMethodsMeta!).map(methodName => factory.createPropertyAssignment(
+                factory.createStringLiteral(methodName), this.currentClass_instanceMethodsMeta![methodName]
+            )),
+            true
+        );
+
+        // Example from readme.md#how-it-works Copy&pasted through the [AST viewer tool](https://ts-ast-viewer.com/)
+        return factory.createMethodDeclaration(
+            [factory.createToken(ts.SyntaxKind.StaticKeyword)],
+            undefined,
+            factory.createIdentifier("getRemoteMethodsMeta"),
+            undefined,
+            undefined,
+            [],
+            factory.createParenthesizedType(factory.createTypeQueryNode(
+                factory.createQualifiedName(
+                    factory.createIdentifier("this"),
+                    factory.createIdentifier("type_remoteMethodsMeta")
+                ),
+                undefined
+            )),
+            factory.createBlock(
+                [
+                    factory.createExpressionStatement(factory.createPropertyAccessExpression(
+                        factory.createThis(),
+                        factory.createIdentifier("__hello_developer__make_sure_your_class_is_a_subclass_of_ServerSession")
+                    )),
+                    factory.createVariableStatement(
+                        undefined,
+                        factory.createVariableDeclarationList(
+                            [factory.createVariableDeclaration(
+                                factory.createIdentifier("typia"),
+                                undefined,
+                                undefined,
+                                factory.createPropertyAccessExpression(
+                                    factory.createThis(),
+                                    factory.createIdentifier("typiaRuntime")
+                                )
+                            )],
+                            ts.NodeFlags.Let
+                        )
+                    ),
+                    factory.createReturnStatement(factory.createObjectLiteralExpression(
+                        [
+                            factory.createPropertyAssignment(
+                                factory.createIdentifier("transformerVersion"),
+                                factory.createObjectLiteralExpression(
+                                    [
+                                        factory.createPropertyAssignment(
+                                            factory.createIdentifier("major"),
+                                            factory.createIdentifier(`${transformerVersion.major}`)
+                                        ),
+                                        factory.createPropertyAssignment(
+                                            factory.createIdentifier("feature"),
+                                            factory.createIdentifier(`${transformerVersion.feature}`)
+                                        )
+                                    ],
+                                    false
+                                )
+                            ),
+                            factory.createPropertyAssignment(
+                                factory.createIdentifier("instanceMethods"),
+                                instanceMethods
+                            )
+                        ],
+                        true
+                    ))
+                ],
+                true
+            )
+        )
+
+    }
+}

package/devPlayground.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# 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":""}

package/devPlayground.js

@@ -0,0 +1,31 @@
+"use strict";
+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 ts = __importStar(require("typescript"));
+const typescript_1 = require("typescript");
+var ScriptKind = ts.ScriptKind;
+let sourceFile = ts.createSourceFile("dev/some.ts", "const i:string = 'myStr';", typescript_1.ScriptTarget.ES2020, false, ScriptKind.JS);
+let i = undefined;
+//# sourceMappingURL=devPlayground.js.map

package/devPlayground.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"devPlayground.js","sourceRoot":"","sources":["devPlayground.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AAAA,+CAAiC;AACjC,2CAAwC;AACxC,IAAO,UAAU,GAAG,EAAE,CAAC,UAAU,CAAC;AAGlC,IAAI,UAAU,GAAG,EAAE,CAAC,gBAAgB,CAAC,aAAa,EAAC,2BAA2B,EAAE,yBAAY,CAAC,MAAM,EAAC,KAAK,EAAE,UAAU,CAAC,EAAE,CAAC,CAAC;AAS1H,IAAI,CAAC,GAA2B,SAAS,CAAA"}

package/devPlayground.ts

@@ -0,0 +1,15 @@
+import * as ts from 'typescript';
+import {ScriptTarget} from 'typescript';
+import ScriptKind = ts.ScriptKind;
+
+
+let sourceFile = ts.createSourceFile("dev/some.ts","const i:string = 'myStr';", ScriptTarget.ES2020,false, ScriptKind.JS);
+
+
+
+type X = {
+
+}
+
+
+let i: Awaited<X> | undefined = undefined

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;AAMhE,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,CAkCT"}

package/index.js

@@ -1,33 +1,62 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 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");
+// From: https://github.com/nonara/ts-patch/discussions/29#discussioncomment-325979
+exports.transformerVersion = { major: 1, feature: 1 };
+/* ****************************************************************************************************************** */
+// 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);
+    /* Transform AST */
+    tsInstance.transform(
+    /* sourceFiles */ program.getSourceFiles().filter(sourceFile => rootFileNames.includes(sourceFile.fileName)), 
+    /* transformerFactoryOOP */ [transformerFactoryOOP.asFunction], compilerOptions);
+    transformerFactoryOOP.transformRunsDone.forEach(transformRun => {
+        if (transformRun.astWasModified) {
+            /* Render modified files and create new SourceFiles for them to use in host's cache */
+            const { printFile } = tsInstance.createPrinter();
+            const sourceFile = transformRun.sourceFile;
+            const updatedSourceFile = tsInstance.createSourceFile(sourceFile.fileName, printFile(sourceFile), sourceFile.languageVersion);
+            updatedSourceFile.version = `${sourceFile.version}_restfuncs_${exports.transformerVersion.major}.${exports.transformerVersion.feature}`;
+            compilerHost.fileCache.set(sourceFile.fileName, updatedSourceFile);
         }
-        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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"}