rbxts-transformer-commit-migrations 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 fome
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/init.js

@@ -0,0 +1,29 @@
+#!/usr/bin/env node
+
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { resolve } from "path";
+
+// find package.json
+let dir = process.cwd();
+while (!existsSync(resolve(dir, "package.json"))) dir = resolve(dir, "..");
+
+const huskyDir = resolve(dir, ".husky");
+const hookFile = resolve(huskyDir, "pre-commit");
+
+if (!existsSync(huskyDir)) {
+  console.error("No .husky folder found. Run `npx husky init` first.");
+  process.exit(1);
+}
+
+const setupResolve = `npx resolve-commit-migrations\n`;
+
+if (existsSync(hookFile)) {
+  const existing = readFileSync(hookFile, "utf-8");
+  if (!existing.includes(setupResolve)) {
+    writeFileSync(hookFile, existing + setupResolve);
+  }
+} else {
+  writeFileSync(hookFile, `#!/bin/sh\n${setupResolve}`);
+}
+
+console.log("Added rbxts-macro stamp to .husky/pre-commit");

package/index.d.ts

@@ -0,0 +1,3 @@
+declare function $migrate(order: number): never;
+declare function $migrate(order: "__resolved"): number;
+declare function $migrate(order: number | "__resolved"): number?;

package/out/cli/resolveMacros.js

@@ -0,0 +1,89 @@
+#!/usr/bin/env node
+import ts from "typescript";
+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) {
+    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.isCallExpression(current) || ts.isPropertyAccessExpression(current)) {
+            current = current.parent;
+        }
+        else {
+            break;
+        }
+    }
+    return null;
+}
+const files = glob.sync("src/**/*.ts");
+const migrations = [];
+const migrationData = {};
+const usedOrders = new Set();
+function walk(node, ctx) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && MACRO_REGEX.test(node.expression.text)) {
+        const entry = findEntryName(node);
+        const orderArg = node.arguments[0];
+        const order = orderArg ? ts.isNumericLiteral(orderArg) ? parseInt(orderArg.getText()) : null : 0;
+        if (order === null) {
+            console.error("Recieved null order when resolving migration macros.");
+            process.exit(1);
+        }
+        if (usedOrders.has(order)) {
+            console.error("Multiple of the same migration orders found. Every migration has to have a unique order.");
+            process.exit(1);
+        }
+        if (!entry) {
+            console.error("Invalid migration entry, maybe you called a $migrate outside a table?");
+            process.exit(1);
+        }
+        if (!orderArg?.getText().includes("__resolved")) {
+            usedOrders.add(order);
+            migrationData[entry] = { timestamp: Date.now(), order };
+            ctx.changed = true;
+        }
+        migrations.push(entry);
+    }
+    ts.forEachChild(node, (node) => {
+        walk(node, ctx);
+    });
+}
+for (const file of files) {
+    const src = readFileSync(file, "utf-8");
+    const sourceFile = ts.createSourceFile(file, src, ts.ScriptTarget.Latest, true);
+    const ctx = { changed: false };
+    walk(sourceFile, ctx);
+    if (ctx.changed) {
+        writeFileSync(file, src.replaceAll(MACRO_CALL_REGEX, `${MACRO}("__resolved")`));
+    }
+}
+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)
+    process.exit(0);
+const newLines = newMigrations
+    .map((e) => `\t${e}: { timestamp: ${migrationData[e].timestamp}, order: ${migrationData[e].order} },`)
+    .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`);
+}
+else {
+    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);
+}
+console.log(`Successfuly resolved ${newMigrations.length} new migrations. [${newMigrations}]`);

package/out/config.js

@@ -0,0 +1,7 @@
+function escapeRegExp(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export const CONFIG = "migrations.config.ts";
+export const MACRO = "$migrate";
+export const MACRO_REGEX = new RegExp(escapeRegExp(MACRO));
+export const MACRO_CALL_REGEX = new RegExp(escapeRegExp(MACRO) + "\\([^)]*\\)", "g");

package/out/index.js

@@ -0,0 +1,28 @@
+import ts from "typescript";
+import { findMacroCall, replaceMacroCall } from "./macro.js";
+import loadMigrationEntries from "./util/loadMigrationEntries.js";
+import { CONFIG } from "./config.js";
+export default function (_) {
+    return (ctx) => {
+        return (file) => {
+            const [entryArr, entries] = loadMigrationEntries(CONFIG);
+            const orderedEntries = entryArr
+                .map((i) => ({ i, timestamp: entries[i].timestamp, order: entries[i].order }))
+                .toSorted((a, b) => a.timestamp - b.timestamp || a.order - b.order)
+                .map(({ i }) => i);
+            console.log(orderedEntries);
+            function visit(node) {
+                if (!ts.isPropertyAssignment(node) || !findMacroCall(node.initializer))
+                    return ts.visitEachChild(node, visit, ctx);
+                const entry = node.name.getText(file);
+                const replacement = orderedEntries.indexOf(entry);
+                if (replacement !== -1) {
+                    const newInit = replaceMacroCall(node.initializer, replacement);
+                    return ts.factory.createPropertyAssignment(node.name, newInit);
+                }
+                return ts.visitEachChild(node, visit, ctx);
+            }
+            return ts.visitNode(file, visit);
+        };
+    };
+}

package/out/macro.js

@@ -0,0 +1,17 @@
+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;
+    }
+    let found;
+    ts.forEachChild(node, (child) => { if (found)
+        return; found = findMacroCall(child); });
+    return found;
+}
+export function replaceMacroCall(node, replacement) {
+    if (ts.isCallExpression(node) && ts.isIdentifier(node.expression) && MACRO_REGEX.test(node.expression.text)) {
+        return ts.factory.createNumericLiteral(replacement);
+    }
+    return ts.visitEachChild(node, (child) => replaceMacroCall(child, replacement), undefined);
+}

package/out/util/loadMigrationEntries.js

@@ -0,0 +1,38 @@
+import ts from "typescript";
+import fs from "fs";
+import path from "path";
+const VAR_NAME = "MIGRATED_ENTRIES";
+function reconstructProperties(properties) {
+    const obj = {};
+    for (const prop of properties) {
+        if (!ts.isPropertyAssignment(prop) || !ts.isNumericLiteral(prop.initializer))
+            continue;
+        const name = ts.isIdentifier(prop.name) ? prop.name.text : prop.name.getText();
+        obj[name] = Number(prop.initializer.text);
+    }
+    return obj;
+}
+export default function (config) {
+    const configPath = path.join(process.cwd(), config);
+    if (!fs.existsSync(configPath))
+        return [[], {}];
+    const sourceFile = ts.createSourceFile(config, fs.readFileSync(configPath, "utf-8"), ts.ScriptTarget.Latest);
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement) || !statement.modifiers?.some(m => m.kind === ts.SyntaxKind.ExportKeyword))
+            continue;
+        const declaration = statement.declarationList.declarations[0];
+        if (!ts.isIdentifier(declaration.name) || declaration.name.text !== VAR_NAME || !declaration.initializer || !ts.isObjectLiteralExpression(declaration.initializer))
+            continue;
+        const result = [];
+        const object = {};
+        for (const prop of declaration.initializer.properties) {
+            if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name) || !ts.isObjectLiteralExpression(prop.initializer))
+                continue;
+            result.push(prop.name.text);
+            object[prop.name.text] = reconstructProperties(prop.initializer.properties);
+            console.log(reconstructProperties(prop.initializer.properties));
+        }
+        return [result, object];
+    }
+    return [[], {}];
+}

package/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "rbxts-transformer-commit-migrations",
+  "version": "1.0.0",
+  "description": "rbxts transformer used in user data migration builder chains",
+  "main": "out/index.js",
+  "typegis": "index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsc"
+  },
+  "bin": {
+    "commit-migrations": "bin/init.js",
+    "resolve-commit-migrations": "out/cli/resolveMacros.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fomecrazy/rbxts-transformer-commit-migrations.git"
+  },
+  "keywords": [
+    "transformer"
+  ],
+  "author": "fome",
+  "license": "MIT",
+  "homepage": "https://github.com/fomecrazy/rbxts-transformer-commit-migrations#readme",
+  "bugs": {
+    "url": "https://github.com/fomecrazy/rbxts-transformer-commit-migrations/issues"
+  },
+  "peerDependencies": {
+    "husky": "*",
+    "jiti": "*",
+    "typescript": "*"
+  },
+  "files": [
+    "out",
+    "index.d.ts"
+  ],
+  "devDependencies": {
+    "@types/node": "^26.5.1",
+    "eslint": "^10.10.0",
+    "eslint-config-prettier": "^10.1.8",
+    "eslint-plugin-prettier": "^5.5.6",
+    "prettier": "^3.9.6",
+    "tsx": "^4.23.13",
+    "typescript-eslint": "^8.70.0"
+  },
+  "dependencies": {
+    "glob": "^13.0.6",
+    "typescript": "^5.5.3"
+  }
+}