rbxts-transformer-commit-migrations 1.0.2 → 1.2.0

package/bin/init.js

@@ -15,7 +15,7 @@ if (!existsSync(huskyDir)) {
 	process.exit(1);
 }
 
-const setupResolve = `npx resolve-commit-migrations\n`;
+const setupResolve = `npx resolve-commit-migrations | xargs git add\n`;
 
 if (existsSync(hookFile)) {
 	const existing = readFileSync(hookFile, "utf-8");

package/index.d.ts

@@ -1,3 +1,3 @@
 export declare function $migrate(order: number): never;
-export declare function $migrate(order: "__resolved"): number;
-export declare function $migrate(order: number | "__resolved"): number | undefined;
+export declare function $migrate(order: "__resolved", path: string[]): number;
+export declare function $migrate(order: number | "__resolved", path: string[]): number | undefined;

package/out/abc.js

@@ -0,0 +1,7 @@
+import { $migrate } from "../index.js";
+function test(b) {
+    return 0;
+}
+export const abc = {
+    hello: { abc: test($migrate(0)) }
+};

package/out/cli/resolveMacros.js

@@ -4,29 +4,56 @@ import { readFileSync, writeFileSync, existsSync } from "fs";
 import { glob } from "glob";
 import loadMigrationEntries from "../util/loadMigrationEntries.js";
 import { CONFIG, MACRO, MACRO_CALL_REGEX, MACRO_REGEX } from "../config.js";
-function findEntryName(node) {
+function getConfigPathFromTransformerConfig(tsconfigPath = "tsconfig.json") {
+    const raw = readFileSync(tsconfigPath, "utf-8");
+    if (!raw)
+        return;
+    const result = ts.parseConfigFileTextToJson(tsconfigPath, raw);
+    if (result.error || !result.config)
+        return undefined;
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment, @typescript-eslint/no-unsafe-member-access
+    const plugins = result.config.compilerOptions?.plugins ?? [];
+    const entry = plugins.find((p) => p.transform === "rbxts-transformer-commit-migrations");
+    if (!entry)
+        return undefined;
+    return entry.configPath;
+}
+function findEntryPath(node) {
+    const parts = [];
     let current = node.parent;
     while (current) {
         if (ts.isPropertyAssignment(current) || ts.isShorthandPropertyAssignment(current)) {
-            const name = ts.isIdentifier(current.name) ? current.name.text : null;
-            return name;
+            if (ts.isIdentifier(current.name) || ts.isStringLiteral(current.name)) {
+                parts.push(current.name.text);
+            }
+            else {
+                return null;
+            }
+            current = current.parent;
         }
-        if (ts.isCallExpression(current) || ts.isPropertyAccessExpression(current)) {
+        else if (ts.isCallExpression(current) ||
+            ts.isPropertyAccessExpression(current) ||
+            ts.isObjectLiteralExpression(current)) {
             current = current.parent;
         }
         else {
             break;
         }
     }
-    return null;
+    return parts.length > 0 ? parts.reverse() : null;
 }
+const config = getConfigPathFromTransformerConfig() ?? CONFIG;
 const files = glob.sync("src/**/*.ts");
 const migrations = [];
 const migrationData = {};
 const usedOrders = new Set();
+const changed = [];
 function walk(node, ctx) {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && MACRO_REGEX.test(node.expression.text)) {
-        const entry = findEntryName(node);
+        const path = findEntryPath(node);
+        if (!path || path.length === 0)
+            return;
+        const entry = path.join("/");
         const orderArg = node.arguments[0];
         const order = orderArg ? ts.isNumericLiteral(orderArg) ? parseInt(orderArg.getText()) : null : 0;
         if (order !== null && usedOrders.has(order)) {
@@ -41,10 +68,10 @@ function walk(node, ctx) {
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
             usedOrders.add(order);
             // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
-            migrationData[entry] = { timestamp: Date.now(), order: order };
+            migrationData[entry] = { timestamp: Date.now(), order: order, path };
             ctx.changed = true;
+            migrations.push(entry);
         }
-        migrations.push(entry);
     }
     ts.forEachChild(node, (node) => {
         walk(node, ctx);
@@ -56,32 +83,39 @@ for (const file of files) {
     const ctx = { changed: false };
     walk(sourceFile, ctx);
     if (ctx.changed) {
+        changed.push(file);
         writeFileSync(file, src.replaceAll(MACRO_CALL_REGEX, `${MACRO}("__resolved")`));
     }
 }
-const [previousMigrations] = loadMigrationEntries(CONFIG);
+const [previousMigrations] = loadMigrationEntries(config);
 const removedMigrations = previousMigrations.filter((v) => !migrations.includes(v));
 if (removedMigrations.length > 0) {
     console.error(`Removed migrations: ${removedMigrations}. Migrations should never be removed!`);
     process.exit(1);
 }
 const newMigrations = migrations.filter((v) => !previousMigrations.includes(v));
-if (newMigrations.length === 0)
+if (newMigrations.length === 0) {
+    console.error("No new migrations to resolve.");
     process.exit(0);
+}
 const newLines = newMigrations
-    .map((e) => `\t${e}: { timestamp: ${migrationData[e].timestamp}, order: ${migrationData[e].order} },`)
+    .map((e) => `\t"${e}": { timestamp: ${migrationData[e].timestamp}, order: ${migrationData[e].order}, path: ${JSON.stringify(migrationData[e].path)} },`)
     .join("\n");
 const migratedEntries = migrations.map((e) => `"${e}"`).join(" | ");
-if (!existsSync(CONFIG)) {
-    writeFileSync(CONFIG, `type MigratedEntries = ${migratedEntries}\n\ninterface MigrationData {\n\ttimestamp: number\n\torder: number\n}\n\n// AUTO-GENERATED MIGRATION CONFIG - DO NOT EDIT\nexport const MIGRATED_ENTRIES: Record<MigratedEntries, MigrationData> = {\n${newLines}\n};\n`);
+if (!existsSync(config)) {
+    writeFileSync(config, `type MigratedEntries = ${migratedEntries}\n\ninterface MigrationData {\n\tpath: string[]\n\ttimestamp: number\n\torder: number\n}\n\n// AUTO-GENERATED MIGRATION CONFIG - DO NOT EDIT\nexport const MIGRATED_ENTRIES: Record<MigratedEntries, MigrationData> = {\n${newLines}\n};\n`);
 }
 else {
-    const lines = readFileSync(CONFIG, "utf-8").split("\n");
+    const lines = readFileSync(config, "utf-8").split("\n");
     const typeIndex = lines.findIndex((l) => l.startsWith("type MigratedEntries"));
     if (typeIndex !== -1) {
         lines[typeIndex] = `type MigratedEntries = ${migratedEntries}`;
     }
     const updated = lines.join("\n").replace(/\};\s*$/, `${newLines}\n};`);
-    writeFileSync(CONFIG, updated);
+    writeFileSync(config, updated);
+}
+changed.push(config);
+console.error(`Successfuly resolved ${newMigrations.length} new migrations. [${newMigrations}]`);
+for (const path of changed) {
+    console.log(path.replace(/\\/g, "/"));
 }
-console.log(`Successfuly resolved ${newMigrations.length} new migrations. [${newMigrations}]`);

package/out/index.js

@@ -1,5 +1,5 @@
 import ts from "typescript";
-import { findMacroCall, replaceMacroCall } from "./macro.js";
+import { findMacroCall, replaceMacroCall } from "./util/macro.js";
 import loadMigrationEntries from "./util/loadMigrationEntries.js";
 import { CONFIG } from "./config.js";
 import { existsSync } from "node:fs";
@@ -18,18 +18,21 @@ export default function (_, config) {
         return (file) => {
             if (config?.files && !config.files.some((f) => file.fileName.includes(f)))
                 return file;
-            function visit(node) {
-                if (!ts.isPropertyAssignment(node) || !findMacroCall(node.initializer))
-                    return ts.visitEachChild(node, visit, ctx);
+            function visit(node, currentPath) {
+                if (!ts.isPropertyAssignment(node))
+                    return ts.visitEachChild(node, (node) => visit(node, currentPath), ctx);
                 const entry = ts.isIdentifier(node.name) ? node.name.text : node.name.getText(file);
-                const replacement = orderedEntries.indexOf(entry);
-                if (replacement !== -1) {
-                    const newInit = replaceMacroCall(node.initializer, replacement);
+                const newPath = [...currentPath, entry];
+                if (!findMacroCall(node.initializer))
+                    return ts.visitEachChild(node, (node) => visit(node, newPath), ctx);
+                const order = orderedEntries.indexOf(newPath.join("/"));
+                if (order !== -1) {
+                    const newInit = replaceMacroCall(node.initializer, order, newPath);
                     return ts.factory.createPropertyAssignment(node.name, newInit);
                 }
-                return ts.visitEachChild(node, visit, ctx);
+                return ts.visitEachChild(node, (node) => visit(node, newPath), ctx);
             }
-            return ts.visitNode(file, visit);
+            return ts.visitNode(file, (node) => visit(node, []));
         };
     };
 }

package/out/macro.js

@@ -4,10 +4,14 @@ export function findMacroCall(node) {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && MACRO_REGEX.test(node.expression.text)) {
         return node;
     }
-    let found;
-    ts.forEachChild(node, (child) => { if (found)
-        return; found = findMacroCall(child); });
-    return found;
+    if (ts.isCallExpression(node)) {
+        for (const arg of node.arguments) {
+            if (ts.isCallExpression(arg) && ts.isIdentifier(arg.expression) && MACRO_REGEX.test(arg.expression.text)) {
+                return arg;
+            }
+        }
+    }
+    return undefined;
 }
 export function replaceMacroCall(node, replacement) {
     if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && MACRO_REGEX.test(node.expression.text)) {

package/out/test.js

@@ -0,0 +1,7 @@
+import { $migrate } from "../index.js";
+function test(a) {
+    return 0;
+}
+const abc = {
+    test: { bruh: test($migrate(0)) }
+};

package/out/util/loadMigrationEntries.js

@@ -26,7 +26,7 @@ export default function (config) {
         const result = [];
         const object = {};
         for (const prop of declaration.initializer.properties) {
-            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name) || !ts.isObjectLiteralExpression(prop.initializer))
+            if (!ts.isPropertyAssignment(prop) || !ts.isStringLiteral(prop.name) || !ts.isObjectLiteralExpression(prop.initializer))
                 continue;
             result.push(prop.name.text);
             object[prop.name.text] = reconstructProperties(prop.initializer.properties);

package/out/util/macro.js

@@ -0,0 +1,35 @@
+import ts from "typescript";
+import { MACRO_REGEX } from "../config.js";
+export function findMacroCall(node) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && MACRO_REGEX.test(node.expression.text)) {
+        return node;
+    }
+    if (ts.isCallExpression(node)) {
+        for (const arg of node.arguments) {
+            if (ts.isCallExpression(arg) && ts.isIdentifier(arg.expression) && MACRO_REGEX.test(arg.expression.text)) {
+                return arg;
+            }
+        }
+    }
+    return undefined;
+}
+export function replaceMacroCall(node, order, path) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression)) {
+        const newArgs = [];
+        let changed = false;
+        for (const arg of node.arguments) {
+            if (ts.isCallExpression(arg) && ts.isIdentifier(arg.expression) && MACRO_REGEX.test(arg.expression.text)) {
+                newArgs.push(ts.factory.createNumericLiteral(order));
+                newArgs.push(ts.factory.createArrayLiteralExpression(path.map(p => ts.factory.createStringLiteral(p)), false));
+                changed = true;
+            }
+            else {
+                newArgs.push(arg);
+            }
+        }
+        if (changed) {
+            return ts.factory.updateCallExpression(node, node.expression, node.typeArguments, newArgs);
+        }
+    }
+    return ts.visitEachChild(node, (child) => replaceMacroCall(child, order, path), undefined);
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rbxts-transformer-commit-migrations",
-  "version": "1.0.2",
+  "version": "1.2.0",
   "description": "rbxts transformer used in user data migration builder chains",
   "main": "out/index.js",
   "type": "module",