@webergency-utils/typechecker 0.1.0

package/dist/transformer.d.ts

@@ -0,0 +1,3 @@
+import ts from 'typescript';
+export { buildValidator, generateHash, buildJsonSchema } from './engine/resolver.js';
+export default function transformer(program: ts.Program): (context: ts.TransformationContext) => (sourceFile: ts.SourceFile) => ts.SourceFile;

package/dist/transformer.js

@@ -0,0 +1,134 @@
+import ts from 'typescript';
+import { buildValidator, generateHash, buildJsonSchema, objectToAst } from './engine/resolver.js';
+export { buildValidator, generateHash, buildJsonSchema } from './engine/resolver.js';
+import { hoistRegistrations } from './engine/hoister.js';
+const TARGET_DECORATORS = ['Query', 'Body', 'Param'];
+const RUNTIME_FUNCTIONS = ['is', 'assert', 'assertGuard', 'validate', 'jsonSchema'];
+export default function transformer(program) {
+    const checker = program.getTypeChecker();
+    return (context) => {
+        return (sourceFile) => {
+            const validatorCache = new Map();
+            const schemasCache = new Map();
+            const requiredUtils = new Set();
+            const visitor = (node) => {
+                // Skip visiting ImportDeclarations to preserve their original symbols and avoid compiler crashes
+                if (ts.isImportDeclaration(node)) {
+                    return node;
+                }
+                // Handle runtime function calls (is, assert, assertGuard, validate, jsonSchema)
+                if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+                    const fnName = node.expression.text;
+                    if (RUNTIME_FUNCTIONS.includes(fnName)) {
+                        const typeArg = node.typeArguments?.[0];
+                        if (typeArg) {
+                            const type = checker.getTypeFromTypeNode(typeArg);
+                            const hash = generateHash(type, checker);
+                            if (!validatorCache.has(hash)) {
+                                buildValidator(type, checker, validatorCache, requiredUtils);
+                            }
+                            if (!schemasCache.has(hash)) {
+                                const schemaObj = buildJsonSchema(type, checker);
+                                schemasCache.set(hash, objectToAst(schemaObj));
+                            }
+                            let getCall;
+                            const arg0 = node.arguments[0] || ts.factory.createIdentifier('undefined');
+                            const arg1 = node.arguments[1] || ts.factory.createIdentifier('undefined');
+                            let hasSchema = false;
+                            let schemaExpr;
+                            if (node.arguments[1]) {
+                                const optArg = node.arguments[1];
+                                const optType = checker.getTypeAtLocation(optArg);
+                                const schemaProp = optType.getProperty('schema');
+                                if (schemaProp) {
+                                    hasSchema = true;
+                                    if (ts.isObjectLiteralExpression(optArg)) {
+                                        const prop = optArg.properties.find(p => {
+                                            if (ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === 'schema') {
+                                                return true;
+                                            }
+                                            if (ts.isShorthandPropertyAssignment(p) && p.name.text === 'schema') {
+                                                return true;
+                                            }
+                                            return false;
+                                        });
+                                        if (prop) {
+                                            if (ts.isPropertyAssignment(prop)) {
+                                                schemaExpr = prop.initializer;
+                                            }
+                                            else if (ts.isShorthandPropertyAssignment(prop)) {
+                                                schemaExpr = prop.name;
+                                            }
+                                        }
+                                    }
+                                    if (!schemaExpr) {
+                                        schemaExpr = ts.factory.createPropertyAccessExpression(optArg, 'schema');
+                                    }
+                                }
+                            }
+                            if (hasSchema && schemaExpr) {
+                                const compileAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'getOrCompileSchema');
+                                getCall = ts.factory.createCallExpression(compileAccess, undefined, [schemaExpr]);
+                            }
+                            else {
+                                const mdStoreAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'getValidator');
+                                getCall = ts.factory.createCallExpression(mdStoreAccess, undefined, [ts.factory.createStringLiteral(hash)]);
+                            }
+                            if (fnName === 'jsonSchema') {
+                                const getSchemaAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'getSchema');
+                                return ts.factory.createCallExpression(getSchemaAccess, undefined, [ts.factory.createStringLiteral(hash)]);
+                            }
+                            else if (fnName === 'validate') {
+                                const mdStoreAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'validate');
+                                return ts.factory.createCallExpression(mdStoreAccess, undefined, [getCall, arg0, arg1]);
+                            }
+                            else if (fnName === 'is') {
+                                const mdStoreAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'is');
+                                return ts.factory.createCallExpression(mdStoreAccess, undefined, [getCall, arg0, arg1]);
+                            }
+                            else if (fnName === 'assert' || fnName === 'assertGuard') {
+                                const mdStoreAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'assert');
+                                return ts.factory.createCallExpression(mdStoreAccess, undefined, [getCall, arg0, arg1]);
+                            }
+                        }
+                    }
+                }
+                // Handle decorators
+                if (ts.isParameter(node) && ts.canHaveDecorators(node)) {
+                    const decorators = ts.getDecorators(node);
+                    if (decorators) {
+                        const updatedDecorators = decorators.map(decorator => {
+                            if (ts.isCallExpression(decorator.expression) && ts.isIdentifier(decorator.expression.expression)) {
+                                const decName = decorator.expression.expression.text;
+                                if (TARGET_DECORATORS.includes(decName)) {
+                                    const typeNode = node.type;
+                                    if (typeNode) {
+                                        const type = checker.getTypeFromTypeNode(typeNode);
+                                        const hash = generateHash(type, checker);
+                                        if (!validatorCache.has(hash)) {
+                                            buildValidator(type, checker, validatorCache, requiredUtils);
+                                        }
+                                        if (!schemasCache.has(hash)) {
+                                            const schemaObj = buildJsonSchema(type, checker);
+                                            schemasCache.set(hash, objectToAst(schemaObj));
+                                        }
+                                        const mdStoreAccess = ts.factory.createPropertyAccessExpression(ts.factory.createIdentifier('MetadataStore'), 'getValidator');
+                                        const getCall = ts.factory.createCallExpression(mdStoreAccess, undefined, [ts.factory.createStringLiteral(hash)]);
+                                        const decoratorArgs = [...decorator.expression.arguments];
+                                        decoratorArgs[1] = getCall;
+                                        return ts.factory.updateDecorator(decorator, ts.factory.createCallExpression(decorator.expression.expression, decorator.expression.typeArguments, decoratorArgs));
+                                    }
+                                }
+                            }
+                            return decorator;
+                        });
+                        return ts.factory.updateParameterDeclaration(node, ts.getModifiers(node), node.dotDotDotToken, node.name, node.questionToken, node.type, node.initializer);
+                    }
+                }
+                return ts.visitEachChild(node, visitor, context);
+            };
+            const transformedFile = ts.visitNode(sourceFile, visitor);
+            return hoistRegistrations(transformedFile, validatorCache, requiredUtils, schemasCache);
+        };
+    };
+}

package/package.json

@@ -0,0 +1,62 @@
+{
+  "name": "@webergency-utils/typechecker",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "TypeScript compiler plugin for runtime validation",
+  "author": "radixxko",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./runtime": {
+      "types": "./dist/runtime/validators.d.ts",
+      "import": "./dist/runtime/validators.js",
+      "require": "./dist/runtime/validators.js",
+      "default": "./dist/runtime/validators.js"
+    },
+    "./transformer": {
+      "types": "./dist/transformer.d.ts",
+      "import": "./dist/transformer.js",
+      "require": "./dist/transformer.js",
+      "default": "./dist/transformer.js"
+    }
+  },
+  "files": [
+    "dist/**/*"
+  ],
+  "scripts": {
+    "lint": "eslint .",
+    "clean": "rm -rf ./dist/* node_modules package-lock.json && npm i",
+    "commit": "node -e \"const version = require('./package.json').version.trim(); require('child_process').execSync('git add . && git commit -m \\\"Version ' + version + '\\\"');\"",
+    "build": "npm run clean && tsc",
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "version": "npm run build && npm publish --access public && npm run commit && git push"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/webergency-utils/typechecker.git"
+  },
+  "bugs": {
+    "url": "https://github.com/webergency-utils/typechecker/issues"
+  },
+  "homepage": "https://github.com/webergency-utils/typechecker#readme",
+  "peerDependencies": {
+    "typescript": ">=5.0.0"
+  },
+  "devDependencies": {
+    "@eslint/js": "^10.0.1",
+    "@stylistic/eslint-plugin": "^5.10.0",
+    "@types/node": "^24.10.1",
+    "@vitest/coverage-v8": "^4.1.6",
+    "eslint": "^10.4.1",
+    "typescript": "^6.0.3",
+    "typescript-eslint": "^8.60.0",
+    "vitest": "^4.1.6"
+  }
+}