@deterministic-code/migraters 0.0.1 → 0.0.3

package/orchestrator/dist/config.d.ts

@@ -0,0 +1,13 @@
+import { type Language } from './languages.ts';
+export declare const CONFIG_NAME = ".migraters.yaml";
+export type MigratersConfig = {
+    language: Language;
+    dialects: string[];
+    binDir: string;
+};
+export declare const configPath: (dir: string) => string;
+export declare const renderConfig: (language: Language, dialects: string[]) => string;
+export declare const writeConfig: (dir: string, language: Language, dialects: string[]) => Promise<string>;
+export declare const parseConfig: (raw: string) => MigratersConfig;
+export declare const findConfigPath: (start: string, fallbackRoot?: string) => string | undefined;
+export declare const loadConfigFile: (path: string) => Promise<MigratersConfig>;

package/orchestrator/dist/config.js

@@ -0,0 +1,48 @@
+import { existsSync } from 'node:fs';
+import { readFile, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { stringify, parse } from 'yaml';
+import { binDirFor, normalizeLanguage } from "./languages.js";
+export const CONFIG_NAME = '.migraters.yaml';
+export const configPath = (dir) => join(dir, CONFIG_NAME);
+export const renderConfig = (language, dialects) => stringify({
+    language,
+    dialects,
+    binDir: binDirFor(language),
+});
+export const writeConfig = async (dir, language, dialects) => {
+    const path = configPath(dir);
+    await writeFile(path, renderConfig(language, dialects));
+    return path;
+};
+export const parseConfig = (raw) => {
+    const doc = parse(raw);
+    const language = typeof doc?.language === 'string' ? normalizeLanguage(doc.language) : undefined;
+    if (!language) {
+        throw new Error(`${CONFIG_NAME} is missing a valid language`);
+    }
+    if (!Array.isArray(doc?.dialects) || doc.dialects.some((d) => typeof d !== 'string')) {
+        throw new Error(`${CONFIG_NAME} is missing a dialects list`);
+    }
+    const binDir = typeof doc.binDir === 'string' && doc.binDir.length > 0 ? doc.binDir : binDirFor(language);
+    return { language, dialects: doc.dialects, binDir };
+};
+export const findConfigPath = (start, fallbackRoot) => {
+    let dir = start;
+    while (true) {
+        const candidate = join(dir, CONFIG_NAME);
+        if (existsSync(candidate))
+            return candidate;
+        const parent = dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    if (fallbackRoot) {
+        const candidate = join(fallbackRoot, CONFIG_NAME);
+        if (existsSync(candidate))
+            return candidate;
+    }
+    return undefined;
+};
+export const loadConfigFile = async (path) => parseConfig(await readFile(path, 'utf8'));

package/orchestrator/dist/dialects.d.ts

@@ -0,0 +1,2 @@
+export declare const normalizeInitProvider: (raw: string) => string | undefined;
+export declare const resolveInitDialects: (raw: string[], all: boolean) => string[];

package/orchestrator/dist/dialects.js

@@ -0,0 +1,25 @@
+import { cliSpec } from "./cli-spec.js";
+const stripKey = (raw) => raw.replace(/[\s_-]/g, '').toLowerCase();
+export const normalizeInitProvider = (raw) => {
+    const key = stripKey(raw);
+    const direct = cliSpec.providers.find((p) => stripKey(p) === key);
+    if (direct)
+        return direct;
+    return cliSpec.provider_aliases[key];
+};
+export const resolveInitDialects = (raw, all) => {
+    if (all)
+        return [...cliSpec.providers];
+    if (raw.length === 0) {
+        throw new Error('pass --dialect <provider> at least once, or --all');
+    }
+    const selected = new Set();
+    for (const value of raw) {
+        const name = normalizeInitProvider(value);
+        if (!name) {
+            throw new Error(`unsupported provider: ${value}`);
+        }
+        selected.add(name);
+    }
+    return cliSpec.providers.filter((name) => selected.has(name));
+};

package/orchestrator/dist/dispatch.d.ts

@@ -0,0 +1,9 @@
+import type { MigratersConfig } from './config.ts';
+export type DispatchPlan = {
+    command: string;
+    args: string[];
+};
+export declare const hostName: (verb: string, win32?: boolean) => string;
+export declare const implementationScript: (verb: string) => string;
+export declare const planDispatch: (root: string, config: MigratersConfig, verb: string, argv: string[], execPath?: string) => DispatchPlan;
+export declare const runDispatch: (verb: string, argv: string[], moduleUrl: string) => Promise<void>;

package/orchestrator/dist/dispatch.js

@@ -0,0 +1,36 @@
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import { findConfigPath, loadConfigFile } from "./config.js";
+import { packageRootFromModule } from "./repo.js";
+import { runCommand } from "./run.js";
+const missingConfigMessage = 'run migrate-init --language <typescript|csharp|rust> before migrate-setup, migrate-up, migrate-down, or migrate-create\n';
+export const hostName = (verb, win32 = process.platform === 'win32') => win32 ? `migrate-${verb}.exe` : `migrate-${verb}`;
+export const implementationScript = (verb) => `migrate-${verb}.js`;
+export const planDispatch = (root, config, verb, argv, execPath = process.execPath) => {
+    const binDir = join(root, config.binDir);
+    if (config.language === 'typescript') {
+        return {
+            command: execPath,
+            args: [join(binDir, implementationScript(verb)), ...argv],
+        };
+    }
+    return {
+        command: join(binDir, hostName(verb)),
+        args: argv,
+    };
+};
+export const runDispatch = async (verb, argv, moduleUrl) => {
+    const root = packageRootFromModule(moduleUrl);
+    const path = findConfigPath(process.cwd(), root);
+    if (!path) {
+        process.stderr.write(missingConfigMessage);
+        process.exit(2);
+    }
+    const config = await loadConfigFile(path);
+    const plan = planDispatch(root, config, verb, argv);
+    if (!existsSync(config.language === 'typescript' ? plan.args[0] : plan.command)) {
+        process.stderr.write(missingConfigMessage);
+        process.exit(2);
+    }
+    process.exit(runCommand(plan.command, plan.args, { cwd: process.cwd() }));
+};

package/{dist → orchestrator/dist}/help.d.ts

@@ -1,2 +1 @@
 export declare const loadHelp: (command: string) => Promise<string>;
-export declare const loadProgramUsage: () => Promise<string>;

package/orchestrator/dist/help.js

@@ -0,0 +1,36 @@
+import { readFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { migrateCommand, usageLine } from "./cli-spec.js";
+import { packageRootFromModule } from "./repo.js";
+const fillTemplate = (text, vars) => {
+    let out = text;
+    for (const [key, value] of Object.entries(vars)) {
+        out = out.replaceAll(`{{${key}}}`, value);
+    }
+    return out;
+};
+const verbFromCommand = (command) => {
+    const verb = command.replace(/^migrate-/, '');
+    if (verb !== 'init' &&
+        verb !== 'setup' &&
+        verb !== 'up' &&
+        verb !== 'down' &&
+        verb !== 'create') {
+        throw new Error(`Unknown migrate command "${command}"`);
+    }
+    return verb;
+};
+const templatesRoot = () => {
+    const here = dirname(fileURLToPath(import.meta.url));
+    const normalized = here.replaceAll('\\', '/');
+    if (normalized.endsWith('/orchestrator/dist')) {
+        return join(packageRootFromModule(import.meta.url), 'shared', 'templates');
+    }
+    return join(here, '..', '..', 'shared', 'templates');
+};
+export const loadHelp = async (command) => {
+    const verb = verbFromCommand(command);
+    const text = await readFile(join(templatesRoot(), 'help', `${verb}.txt`), 'utf8');
+    return fillTemplate(text, { command: migrateCommand(verb), usage: usageLine(verb) });
+};

package/orchestrator/dist/languages.d.ts

@@ -0,0 +1,4 @@
+export declare const LANGUAGES: readonly ["typescript", "csharp", "rust"];
+export type Language = (typeof LANGUAGES)[number];
+export declare const normalizeLanguage: (raw: string) => Language | undefined;
+export declare const binDirFor: (language: Language) => string;

package/orchestrator/dist/languages.js

@@ -0,0 +1,12 @@
+export const LANGUAGES = ['typescript', 'csharp', 'rust'];
+export const normalizeLanguage = (raw) => {
+    const key = raw.replace(/[\s_-]/g, '').toLowerCase();
+    return LANGUAGES.find((name) => name === key);
+};
+export const binDirFor = (language) => {
+    if (language === 'typescript')
+        return 'typescript/dist/src/bin';
+    if (language === 'csharp')
+        return 'csharp/bin/Debug/net9.0';
+    return 'rust/target/debug';
+};

package/orchestrator/dist/manifests.d.ts

@@ -0,0 +1,8 @@
+export declare const cargoDefaultFeaturesLine: (dialects: string[]) => string;
+export declare const setCargoDefaultFeatures: (cargoToml: string, dialects: string[]) => string;
+export declare const rustDialectCrate: (dialect: string) => string;
+export declare const rustDialectIdent: (dialect: string) => string;
+export declare const rustDialectPath: (dialect: string) => string;
+export declare const renderAttachedDialects: (dialects: string[]) => string;
+export declare const setCargoDialectDeps: (cargoToml: string, dialects: string[]) => string;
+export declare const renderDialectsProps: (dialects: string[]) => string;

package/orchestrator/dist/manifests.js

@@ -0,0 +1,53 @@
+const DIALECT_PROJECTS = {
+    sqlite: 'Dialects/Sqlite/MigrateSqlite.csproj',
+    postgres: 'Dialects/Postgres/MigratePostgres.csproj',
+    mysql: 'Dialects/Mysql/MigrateMysql.csproj',
+    sqlserver: 'Dialects/SqlServer/MigrateSqlServer.csproj',
+    oracle: 'Dialects/Oracle/MigrateOracle.csproj',
+};
+export const cargoDefaultFeaturesLine = (dialects) => `default = [${dialects.map((name) => `"${name}"`).join(', ')}]`;
+export const setCargoDefaultFeatures = (cargoToml, dialects) => {
+    const replacement = cargoDefaultFeaturesLine(dialects);
+    const lines = cargoToml.split('\n');
+    let replaced = false;
+    const out = lines.map((line) => {
+        if (!replaced && line.trimStart().startsWith('default = [')) {
+            replaced = true;
+            const indent = line.slice(0, line.length - line.trimStart().length);
+            return `${indent}${replacement}`;
+        }
+        return line;
+    });
+    if (!replaced) {
+        throw new Error('Cargo.toml is missing a features default = [...] line');
+    }
+    return out.join('\n');
+};
+export const rustDialectCrate = (dialect) => `migraters-${dialect}`;
+export const rustDialectIdent = (dialect) => rustDialectCrate(dialect).replaceAll('-', '_');
+export const rustDialectPath = (dialect) => `dialects/${dialect}`;
+export const renderAttachedDialects = (dialects) => [
+    '// Generated by migrate-init. Do not edit.',
+    '#![allow(unused_imports)]',
+    ...dialects.map((name) => `use ${rustDialectIdent(name)} as _;`),
+    '',
+].join('\n');
+export const setCargoDialectDeps = (cargoToml, dialects) => {
+    const marker = '# migrate-init-dialects';
+    const lines = dialects.map((name) => `${rustDialectCrate(name)} = { path = "${rustDialectPath(name)}" }`);
+    const block = [`${marker}-start`, ...lines, `${marker}-end`].join('\n');
+    if (cargoToml.includes(`${marker}-start`)) {
+        return cargoToml.replace(new RegExp(`${marker}-start[\\s\\S]*?${marker}-end`), block);
+    }
+    if (!cargoToml.includes('[dependencies]')) {
+        throw new Error('Cargo.toml is missing [dependencies]');
+    }
+    return cargoToml.replace('[dependencies]', `[dependencies]\n${block}`);
+};
+export const renderDialectsProps = (dialects) => {
+    const refs = dialects
+        .map((name) => DIALECT_PROJECTS[name])
+        .filter((path) => Boolean(path))
+        .map((path) => `    <ProjectReference Include="$(MSBuildThisFileDirectory)${path}" />`);
+    return ['<Project>', '  <ItemGroup>', ...refs, '  </ItemGroup>', '</Project>', ''].join('\n');
+};

package/orchestrator/dist/migrate-create.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runDispatch } from "./dispatch.js";
+await runDispatch('create', process.argv.slice(2), import.meta.url);

package/orchestrator/dist/migrate-down.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runDispatch } from "./dispatch.js";
+await runDispatch('down', process.argv.slice(2), import.meta.url);

package/orchestrator/dist/migrate-init.js

@@ -0,0 +1,37 @@
+#!/usr/bin/env node
+import { loadHelp } from "./help.js";
+import { parseInitArgv, resolveInitSelection } from "./parse-init.js";
+import { packageRootFromModule } from "./repo.js";
+import { runLanguageInit } from "./run-init.js";
+const HELP_TEXT = await loadHelp('migrate-init');
+const main = async () => {
+    let parsed;
+    try {
+        parsed = parseInitArgv(process.argv.slice(2));
+    }
+    catch (e) {
+        const err = e;
+        process.stderr.write(`${err.message}\n`);
+        process.exit(2);
+    }
+    if (parsed.help) {
+        process.stderr.write(HELP_TEXT);
+        process.exit(0);
+    }
+    let selection;
+    try {
+        selection = resolveInitSelection(parsed);
+    }
+    catch (e) {
+        const err = e;
+        process.stderr.write(`${err.message}\n`);
+        process.exit(2);
+    }
+    const root = packageRootFromModule(import.meta.url);
+    await runLanguageInit(root, selection.language, selection.dialects);
+};
+main().catch((e) => {
+    const err = e;
+    process.stderr.write(`${err?.stack ?? err?.message ?? String(e)}\n`);
+    process.exit(1);
+});

package/orchestrator/dist/migrate-setup.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runDispatch } from "./dispatch.js";
+await runDispatch('setup', process.argv.slice(2), import.meta.url);

package/orchestrator/dist/migrate-up.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { runDispatch } from "./dispatch.js";
+await runDispatch('up', process.argv.slice(2), import.meta.url);

package/orchestrator/dist/parse-init.d.ts

@@ -0,0 +1,12 @@
+import { type Language } from './languages.ts';
+export type ParsedInit = {
+    help?: boolean;
+    language?: Language;
+    dialects: string[];
+    all: boolean;
+};
+export declare const parseInitArgv: (argv: string[]) => ParsedInit;
+export declare const resolveInitSelection: (parsed: ParsedInit) => {
+    language: Language;
+    dialects: string[];
+};

package/orchestrator/dist/parse-init.js

@@ -0,0 +1,56 @@
+import { resolveInitDialects } from "./dialects.js";
+import { normalizeLanguage } from "./languages.js";
+const takeFlag = (rest, i, arg, flag) => {
+    const eq = `${flag}=`;
+    if (arg === flag) {
+        const value = rest[i + 1];
+        if (value === undefined)
+            return undefined;
+        return { value, next: i + 1 };
+    }
+    if (arg.startsWith(eq))
+        return { value: arg.slice(eq.length), next: i };
+    return undefined;
+};
+export const parseInitArgv = (argv) => {
+    const dialects = [];
+    let language;
+    let all = false;
+    for (let i = 0; i < argv.length; i++) {
+        const a = argv[i];
+        if (a === '-h' || a === '--help') {
+            return { help: true, dialects, all };
+        }
+        if (a === '--all') {
+            all = true;
+            continue;
+        }
+        const languageTaken = takeFlag(argv, i, a, '--language');
+        if (languageTaken) {
+            const name = normalizeLanguage(languageTaken.value);
+            if (!name) {
+                throw new Error(`unsupported language: ${languageTaken.value}`);
+            }
+            language = name;
+            i = languageTaken.next;
+            continue;
+        }
+        const taken = takeFlag(argv, i, a, '--dialect');
+        if (taken) {
+            dialects.push(taken.value);
+            i = taken.next;
+            continue;
+        }
+        throw new Error(`unknown arg: ${a}`);
+    }
+    return { language, dialects, all };
+};
+export const resolveInitSelection = (parsed) => {
+    if (!parsed.language) {
+        throw new Error('pass --language <typescript|csharp|rust>');
+    }
+    return {
+        language: parsed.language,
+        dialects: resolveInitDialects(parsed.dialects, parsed.all),
+    };
+};

package/orchestrator/dist/repo.d.ts

@@ -0,0 +1,2 @@
+export declare const findPackageRoot: (start: string) => string;
+export declare const packageRootFromModule: (moduleUrl: string) => string;

package/orchestrator/dist/repo.js

@@ -0,0 +1,19 @@
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+const isPackageRoot = (dir) => existsSync(join(dir, 'bundle.yaml')) &&
+    existsSync(join(dir, 'rust', 'Cargo.toml')) &&
+    existsSync(join(dir, 'csharp', 'MigrateRunner.csproj'));
+export const findPackageRoot = (start) => {
+    let dir = start;
+    while (true) {
+        if (isPackageRoot(dir))
+            return dir;
+        const parent = dirname(dir);
+        if (parent === dir) {
+            throw new Error('could not find migraters package root');
+        }
+        dir = parent;
+    }
+};
+export const packageRootFromModule = (moduleUrl) => findPackageRoot(dirname(fileURLToPath(moduleUrl)));

package/orchestrator/dist/run-init.d.ts

@@ -0,0 +1,2 @@
+import { type Language } from './languages.ts';
+export declare const runLanguageInit: (root: string, language: Language, dialects: string[]) => Promise<void>;

package/orchestrator/dist/run-init.js

@@ -0,0 +1,66 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { cliSpec } from "./cli-spec.js";
+import { writeConfig } from "./config.js";
+import { renderAttachedDialects, renderDialectsProps, setCargoDialectDeps } from "./manifests.js";
+import { requireStatus, runCommand } from "./run.js";
+const npmFlags = ['--no-audit', '--no-fund', '--loglevel=error'];
+const npmCmd = () => (process.platform === 'win32' ? 'npm.cmd' : 'npm');
+const dialectPackage = (name) => `@deterministic-code/migraters-${name}`;
+const dialectRuntimeDeps = async (tsRoot, dialects) => {
+    const names = new Set();
+    for (const dialect of dialects) {
+        const raw = await readFile(join(tsRoot, 'dialects', dialect, 'package.json'), 'utf8');
+        const pkg = JSON.parse(raw);
+        for (const name of Object.keys(pkg.dependencies ?? {})) {
+            if (!name.startsWith('@types/'))
+                names.add(name);
+        }
+    }
+    return [...names];
+};
+const initTypescript = async (root, dialects) => {
+    const tsRoot = join(root, 'typescript');
+    requireStatus(runCommand(npmCmd(), ['install', ...npmFlags], { cwd: tsRoot }));
+    const specs = dialects.map((name) => join(tsRoot, 'dialects', name));
+    if (specs.length > 0) {
+        requireStatus(runCommand(npmCmd(), ['install', ...npmFlags, '--no-save', ...specs], { cwd: tsRoot }));
+    }
+    const remove = cliSpec.providers
+        .filter((name) => !dialects.includes(name))
+        .map(dialectPackage);
+    if (remove.length > 0) {
+        requireStatus(runCommand(npmCmd(), ['uninstall', ...npmFlags, '--no-save', ...remove], { cwd: tsRoot }));
+    }
+    const drivers = await dialectRuntimeDeps(tsRoot, dialects);
+    if (drivers.length > 0) {
+        requireStatus(runCommand(npmCmd(), ['install', ...npmFlags, '--no-save', ...drivers], { cwd: tsRoot }));
+    }
+    requireStatus(runCommand(npmCmd(), ['run', 'build'], { cwd: tsRoot }));
+};
+const initCsharp = async (root, dialects) => {
+    const propsPath = join(root, 'csharp', 'dialects.props');
+    await writeFile(propsPath, renderDialectsProps(dialects));
+    requireStatus(runCommand('dotnet', ['build', join(root, 'csharp', 'MigrateRunner.csproj')], { cwd: root }));
+};
+const initRust = async (root, dialects) => {
+    const cargoPath = join(root, 'rust', 'Cargo.toml');
+    const raw = await readFile(cargoPath, 'utf8');
+    await writeFile(cargoPath, setCargoDialectDeps(raw, dialects));
+    await writeFile(join(root, 'rust', 'src', 'attached_dialects.rs'), renderAttachedDialects(dialects));
+    requireStatus(runCommand('cargo', ['build', '--manifest-path', join(root, 'rust', 'Cargo.toml')], {
+        cwd: root,
+        env: { ...process.env, CARGO_TARGET_DIR: join(root, 'rust', 'target') },
+    }));
+};
+export const runLanguageInit = async (root, language, dialects) => {
+    if (language === 'typescript')
+        await initTypescript(root, dialects);
+    else if (language === 'csharp')
+        await initCsharp(root, dialects);
+    else
+        await initRust(root, dialects);
+    await writeConfig(process.cwd(), language, dialects);
+    process.stdout.write(`Enabled language: ${language}\n`);
+    process.stdout.write(`Enabled dialects: ${dialects.join(', ')}\n`);
+};

package/orchestrator/dist/run.d.ts

@@ -0,0 +1,3 @@
+import { type SpawnSyncOptions } from 'node:child_process';
+export declare const runCommand: (command: string, args: string[], options?: SpawnSyncOptions) => number;
+export declare const requireStatus: (status: number) => void;

package/orchestrator/dist/run.js

@@ -0,0 +1,16 @@
+import { spawnSync } from 'node:child_process';
+export const runCommand = (command, args, options = {}) => {
+    const result = spawnSync(command, args, {
+        stdio: 'inherit',
+        ...options,
+    });
+    if (result.error) {
+        throw result.error;
+    }
+    return result.status ?? 1;
+};
+export const requireStatus = (status) => {
+    if (status !== 0) {
+        process.exit(status);
+    }
+};

package/orchestrator/prepare.js

@@ -0,0 +1,21 @@
+#!/usr/bin/env node
+import { spawnSync } from 'node:child_process';
+import { existsSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const orch = dirname(fileURLToPath(import.meta.url));
+const src = join(orch, 'src', 'migrate-init.ts');
+const built = join(orch, 'dist', 'migrate-init.js');
+if (!existsSync(src)) {
+  if (!existsSync(built)) {
+    process.stderr.write('orchestrator dist is missing; this install cannot run migrate-init\n');
+    process.exit(1);
+  }
+  process.exit(0);
+}
+const result = spawnSync('npx', ['tsc', '-p', join(orch, 'tsconfig.json')], {
+  stdio: 'inherit',
+  shell: process.platform === 'win32',
+});
+process.exit(result.status ?? 1);

package/{tsconfig.build.json → orchestrator/tsconfig.json}

@@ -15,5 +15,5 @@
     "forceConsistentCasingInFileNames": true
   },
   "include": ["src/**/*.ts"],
-    "exclude": ["src/**/*.test.ts", "src/generate-help.ts"]
+  "exclude": ["src/**/*.test.ts"]
 }