@deterministic-code/migraters 0.0.4 → 0.0.6

package/csharp/Providers/Sql/ConnectionNormalizer.cs

@@ -0,0 +1,78 @@
+namespace Deterministic.MigrateRunner;
+
+internal static class ConnectionNormalizer
+{
+    public static string Sqlite(string? connection)
+    {
+        var c = connection ?? string.Empty;
+        if (c.Contains('=', StringComparison.Ordinal))
+            return c;
+        if (c.StartsWith("sqlite://", StringComparison.OrdinalIgnoreCase))
+        {
+            var path = RelativeDotPath(c["sqlite://".Length..]);
+            return string.IsNullOrEmpty(path) ? "Data Source=:memory:" : $"Data Source={path}";
+        }
+        return string.IsNullOrEmpty(c) ? "Data Source=:memory:" : $"Data Source={c}";
+    }
+
+    public static bool SqliteIsMemory(string? connection)
+    {
+        var s = (connection ?? string.Empty).Trim();
+        if (s.Length == 0 || string.Equals(s, ":memory:", StringComparison.Ordinal))
+            return true;
+        var compact = s.Replace(" ", string.Empty, StringComparison.Ordinal);
+        return compact.Contains(":memory:", StringComparison.OrdinalIgnoreCase)
+            || compact.Contains("?mode=memory", StringComparison.OrdinalIgnoreCase)
+            || compact.Contains("&mode=memory", StringComparison.OrdinalIgnoreCase)
+            || compact.Contains(";mode=memory", StringComparison.OrdinalIgnoreCase)
+            || compact.StartsWith("mode=memory", StringComparison.OrdinalIgnoreCase);
+    }
+
+    public static string? SqliteFilesystemPath(string? connection)
+    {
+        if (SqliteIsMemory(connection))
+            return null;
+        var s = connection!.Trim();
+        var eq = s.IndexOf('=', StringComparison.Ordinal);
+        if (eq >= 0)
+        {
+            var key = s[..eq].Trim().Replace(" ", string.Empty);
+            if (string.Equals(key, "DataSource", StringComparison.OrdinalIgnoreCase))
+            {
+                s = s[(eq + 1)..].Trim();
+                var semi = s.IndexOf(';', StringComparison.Ordinal);
+                if (semi >= 0)
+                    s = s[..semi].Trim();
+            }
+        }
+        foreach (var prefix in new[] { "sqlite://", "sqlite:", "file:" })
+        {
+            if (s.StartsWith(prefix, StringComparison.OrdinalIgnoreCase))
+            {
+                s = s[prefix.Length..];
+                break;
+            }
+        }
+        var q = s.IndexOf('?', StringComparison.Ordinal);
+        if (q >= 0)
+            s = s[..q];
+        s = RelativeDotPath(s);
+        return s.Length == 0 ? null : s;
+    }
+
+    // sqlite:///./app.sqlite keeps the URI slash and would open /./app.sqlite.
+    private static string RelativeDotPath(string path) =>
+        path.StartsWith("/./", StringComparison.Ordinal) ? path[1..] : path;
+
+    public static string Oracle(string connection)
+    {
+        var slash = connection.IndexOf('/');
+        var at = connection.LastIndexOf('@');
+        if (slash <= 0 || at <= slash)
+            throw new ArgumentException("Oracle connection must look like user/password@connectString");
+        var user = connection[..slash];
+        var password = connection[(slash + 1)..at];
+        var dataSource = connection[(at + 1)..];
+        return $"User Id={user};Password={password};Data Source={dataSource}";
+    }
+}

package/csharp/{Infrastructure → Providers/Sql}/DbExecute.cs

@@ -19,7 +19,7 @@ internal static class DbExecute
     public static async Task CatalogWriteAsync(
         DbConnection conn,
         DbTransaction? tx,
-        ISqlDialect dialect,
+        SqlRun dialect,
         string sql,
         params (string name, object value)[] parameters
     )
@@ -35,7 +35,7 @@ internal static class DbExecute
 
     public static async Task ApplyStatementsAsync(
         DbConnection conn,
-        ISqlDialect dialect,
+        SqlRun dialect,
         string sql,
         Func<DbTransaction?, Task> catalogWrite
     )

package/csharp/Providers/Sql/GlobalUsings.cs

@@ -0,0 +1,6 @@
+global using System.Collections.Concurrent;
+global using System.Data.Common;
+global using System.Globalization;
+global using System.Text;
+global using System.Text.RegularExpressions;
+global using Deterministic.MigrateRunner;

package/csharp/{Infrastructure/MigrateLog.cs → Providers/Sql/SqlCatalog.cs}

@@ -1,10 +1,25 @@
 namespace Deterministic.MigrateRunner;
 
-internal static class MigrateLog
+internal static class SqlCatalog
 {
-    public static async Task<long> InsertStartedAsync(
+    public static async Task<Dictionary<string, string?>> AppliedAsync(DbConnection conn, SqlRun dialect)
+    {
+        var map = new Dictionary<string, string?>(StringComparer.Ordinal);
+        using var cmd = conn.CreateCommand();
+        cmd.CommandText = dialect.SelectAppliedChecksumSql;
+        using var reader = await cmd.ExecuteReaderAsync().ConfigureAwait(false);
+        while (await reader.ReadAsync().ConfigureAwait(false))
+        {
+            var name = Migrations.CatalogName(reader.GetString(0));
+            var checksum = reader.IsDBNull(1) ? null : reader.GetString(1);
+            map[name] = checksum;
+        }
+        return map;
+    }
+
+    public static async Task<long> InsertLogStartedAsync(
         DbConnection conn,
-        ISqlDialect dialect,
+        SqlRun dialect,
         string name,
         string direction
     )
@@ -25,9 +40,9 @@ internal static class MigrateLog
         return Convert.ToInt64(value, CultureInfo.InvariantCulture);
     }
 
-    public static async Task UpdateAsync(
+    public static async Task UpdateLogAsync(
         DbConnection conn,
-        ISqlDialect dialect,
+        SqlRun dialect,
         long id,
         string status,
         long durationMs,

package/csharp/{Abstractions/SqlDialect.cs → Providers/Sql/SqlRun.cs}

@@ -1,7 +1,8 @@
 namespace Deterministic.MigrateRunner;
 
-public sealed class SqlDialect : ISqlDialect
+internal sealed class SqlRun
 {
+    private readonly ConcurrentDictionary<string, DbConnection> _open = new(StringComparer.Ordinal);
     private readonly Func<string, string> _normalize;
     private readonly Func<string, DbConnection> _createConnection;
     private readonly Action<DbCommand, string, object> _addParameter;
@@ -12,9 +13,8 @@ public sealed class SqlDialect : ISqlDialect
     private readonly Func<string, Task>? _createDatabase;
     private readonly Func<int, string> _limitClause;
 
-    public SqlDialect(
+    public SqlRun(
         string name,
-        IReadOnlyList<string> connectionEnvironmentVariables,
         bool useTransaction,
         Func<string, string> normalizeConnectionString,
         Func<string, DbConnection> createConnection,
@@ -29,7 +29,6 @@ public sealed class SqlDialect : ISqlDialect
     )
     {
         Name = name;
-        ConnectionEnvironmentVariables = connectionEnvironmentVariables;
         UseTransaction = useTransaction;
         NowExpr = nowExpr;
         _normalize = normalizeConnectionString;
@@ -44,7 +43,6 @@ public sealed class SqlDialect : ISqlDialect
     }
 
     public string Name { get; }
-    public IReadOnlyList<string> ConnectionEnvironmentVariables { get; }
     public bool UseTransaction { get; }
     public string NowExpr { get; }
     public string MigratesDdl => SqlTemplates.Read(Name, "migrates");
@@ -68,6 +66,67 @@ public sealed class SqlDialect : ISqlDialect
     public Task CreateDatabaseIfMissingAsync(string connection) =>
         _createDatabase?.Invoke(connection) ?? Task.CompletedTask;
 
+    public async Task Setup(string connection)
+    {
+        var conn = await OpenAsync(connection, requireExisting: false).ConfigureAwait(false);
+        await DbExecute.NonQueryAsync(conn, null, MigratesDdl).ConfigureAwait(false);
+        await DbExecute.NonQueryAsync(conn, null, MigrateLogsDdl).ConfigureAwait(false);
+    }
+
+    public async Task<IReadOnlyDictionary<string, string?>> Applied(string connection)
+    {
+        var conn = await OpenAsync(connection, requireExisting: true).ConfigureAwait(false);
+        return await SqlCatalog.AppliedAsync(conn, this).ConfigureAwait(false);
+    }
+
+    public async Task MigrateUp(string connection, string name, string body, string checksum)
+    {
+        var conn = await OpenAsync(connection, requireExisting: true).ConfigureAwait(false);
+        await DbExecute.ApplyStatementsAsync(
+            conn,
+            this,
+            body,
+            tx =>
+                DbExecute.CatalogWriteAsync(
+                    conn,
+                    tx,
+                    this,
+                    InsertAppliedSql,
+                    ("p1", name),
+                    ("p2", checksum)
+                )
+        ).ConfigureAwait(false);
+    }
+
+    public async Task MigrateDown(string connection, string name, string body)
+    {
+        var conn = await OpenAsync(connection, requireExisting: true).ConfigureAwait(false);
+        await DbExecute.ApplyStatementsAsync(
+            conn,
+            this,
+            body,
+            tx => DbExecute.CatalogWriteAsync(conn, tx, this, DeleteAppliedSql, ("p1", name))
+        ).ConfigureAwait(false);
+    }
+
+    public async Task<long> Log(
+        string connection,
+        long? id,
+        string name,
+        string direction,
+        string? status,
+        long durationMs,
+        string? error
+    )
+    {
+        var conn = await OpenAsync(connection, requireExisting: id is not null).ConfigureAwait(false);
+        if (id is null)
+            return await SqlCatalog.InsertLogStartedAsync(conn, this, name, direction).ConfigureAwait(false);
+        await SqlCatalog.UpdateLogAsync(conn, this, id.Value, status ?? "started", durationMs, error)
+            .ConfigureAwait(false);
+        return id.Value;
+    }
+
     public static void Bind(DbCommand command, string parameterName, object value)
     {
         var p = command.CreateParameter();
@@ -75,4 +134,17 @@ public sealed class SqlDialect : ISqlDialect
         p.Value = value;
         command.Parameters.Add(p);
     }
+
+    private async Task<DbConnection> OpenAsync(string connection, bool requireExisting)
+    {
+        if (requireExisting && PrerequisiteError(connection) is { } error)
+            throw new InvalidOperationException(error);
+        var key = _normalize(connection);
+        if (_open.TryGetValue(key, out var existing))
+            return existing;
+        var conn = _createConnection(key);
+        await conn.OpenAsync().ConfigureAwait(false);
+        _open[key] = conn;
+        return conn;
+    }
 }

package/csharp/{Dialects → Providers}/SqlServer/MigrateSqlServer.csproj

@@ -9,6 +9,8 @@
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\MigrateRunner.Core.csproj" />
+    <InternalsVisibleTo Include="MigrateRunner.Tests" />
+    <InternalsVisibleTo Include="MigrateRunner.ProviderTests" />
     <PackageReference Include="Microsoft.Data.SqlClient" Version="6.0.2" />
   </ItemGroup>
 </Project>

package/csharp/Providers/SqlServer/SqlServerProvider.cs

@@ -0,0 +1,45 @@
+using Microsoft.Data.SqlClient;
+
+namespace Deterministic.MigrateRunner;
+
+public sealed class SqlServerProvider : IDatasourceProvider
+{
+    private readonly SqlRun _sql = new(
+        "sqlserver",
+        useTransaction: true,
+        connection => connection,
+        s => new SqlConnection(s),
+        (cmd, n, v) => SqlRun.Bind(cmd, $"@{n}", v),
+        ident => $"[{ident}]",
+        name => $"@{name}",
+        createDatabase: SqlServerCreateDatabase.IfMissingAsync,
+        nowExpr: "SYSUTCDATETIME()",
+        limitClause: n => $"OFFSET 0 ROWS FETCH NEXT {n} ROWS ONLY"
+    );
+
+    public string Name => _sql.Name;
+    public void PrepareSetup(string connection) => _sql.PrepareSetup(connection);
+    public Task CreateDatabaseIfMissingAsync(string connection) =>
+        _sql.CreateDatabaseIfMissingAsync(connection);
+    public Task Setup(string connection) => _sql.Setup(connection);
+    public Task<IReadOnlyDictionary<string, string?>> Applied(string connection) =>
+        _sql.Applied(connection);
+    public Task MigrateUp(string connection, string name, string body, string checksum) =>
+        _sql.MigrateUp(connection, name, body, checksum);
+    public Task MigrateDown(string connection, string name, string body) =>
+        _sql.MigrateDown(connection, name, body);
+    public Task<long> Log(
+        string connection,
+        long? id,
+        string name,
+        string direction,
+        string? status,
+        long durationMs,
+        string? error
+    ) => _sql.Log(connection, id, name, direction, status, durationMs, error);
+
+    internal SqlRun Sql => _sql;
+    public string NormalizeConnectionString(string connection) =>
+        _sql.NormalizeConnectionString(connection);
+    public string? PrerequisiteError(string connection) => _sql.PrerequisiteError(connection);
+}

package/csharp/{Dialects → Providers}/Sqlite/MigrateSqlite.csproj

@@ -6,9 +6,13 @@
     <RootNamespace>Deterministic.MigrateRunner</RootNamespace>
     <AssemblyName>MigrateSqlite</AssemblyName>
     <IsPackable>false</IsPackable>
+    <CopyLocalLockFileAssemblies>true</CopyLocalLockFileAssemblies>
   </PropertyGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\MigrateRunner.Core.csproj" />
+    <InternalsVisibleTo Include="MigrateRunner.Tests" />
+    <InternalsVisibleTo Include="MigrateRunner.ProviderTests" />
     <PackageReference Include="Microsoft.Data.Sqlite" Version="9.0.0" />
+    <PackageReference Include="SQLitePCLRaw.bundle_e_sqlite3" Version="2.1.10" />
   </ItemGroup>
 </Project>

package/csharp/Providers/Sqlite/SqliteProvider.cs

@@ -0,0 +1,71 @@
+using Microsoft.Data.Sqlite;
+using SQLitePCL;
+
+namespace Deterministic.MigrateRunner;
+
+public sealed class SqliteProvider : IDatasourceProvider
+{
+    private readonly SqlRun _sql;
+
+    static SqliteProvider() => Batteries.Init();
+
+    public SqliteProvider()
+    {
+        _sql = new SqlRun(
+            "sqlite",
+            useTransaction: true,
+            ConnectionNormalizer.Sqlite,
+            s => new SqliteConnection(s),
+            (cmd, n, v) => SqlRun.Bind(cmd, $"${n}", v),
+            ident => $"\"{ident}\"",
+            name => $"${name}",
+            connection =>
+            {
+                var path = ConnectionNormalizer.SqliteFilesystemPath(connection);
+                return path is null || File.Exists(path)
+                    ? null
+                    : HelpTemplates.Message(
+                        "errors/sqlite-prerequisite",
+                        new Dictionary<string, string> { ["path"] = path }
+                    );
+            },
+            PrepareParent
+        );
+    }
+
+    public string Name => _sql.Name;
+    public void PrepareSetup(string connection) => _sql.PrepareSetup(connection);
+    public Task CreateDatabaseIfMissingAsync(string connection) =>
+        _sql.CreateDatabaseIfMissingAsync(connection);
+    public Task Setup(string connection) => _sql.Setup(connection);
+    public Task<IReadOnlyDictionary<string, string?>> Applied(string connection) =>
+        _sql.Applied(connection);
+    public Task MigrateUp(string connection, string name, string body, string checksum) =>
+        _sql.MigrateUp(connection, name, body, checksum);
+    public Task MigrateDown(string connection, string name, string body) =>
+        _sql.MigrateDown(connection, name, body);
+    public Task<long> Log(
+        string connection,
+        long? id,
+        string name,
+        string direction,
+        string? status,
+        long durationMs,
+        string? error
+    ) => _sql.Log(connection, id, name, direction, status, durationMs, error);
+
+    internal SqlRun Sql => _sql;
+    public string NormalizeConnectionString(string connection) =>
+        _sql.NormalizeConnectionString(connection);
+    public string? PrerequisiteError(string connection) => _sql.PrerequisiteError(connection);
+
+    private static void PrepareParent(string connection)
+    {
+        var path = ConnectionNormalizer.SqliteFilesystemPath(connection);
+        if (path is null)
+            return;
+        var parent = Path.GetDirectoryName(path);
+        if (!string.IsNullOrEmpty(parent))
+            Directory.CreateDirectory(parent);
+    }
+}

package/orchestrator/dist/config.d.ts

@@ -1,12 +1,13 @@
 import { type Language } from './languages.ts';
+import { type ProviderEntry } from './provider-location.ts';
 export declare const CONFIG_NAME = ".migraters.yaml";
 export type MigratersConfig = {
     language: Language;
-    dialects: string[];
+    providers: ProviderEntry[];
     binDir: string;
 };
 export declare const configPath: (dir: string) => string;
-export declare const renderConfig: (language: Language, dialects: string[]) => string;
+export declare const renderConfig: (language: Language, dialects: string[], configDir?: 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;

package/orchestrator/dist/config.js

@@ -3,29 +3,51 @@ import { readFile, writeFile } from 'node:fs/promises';
 import { dirname, join } from 'node:path';
 import { stringify, parse } from 'yaml';
 import { binDirFor, normalizeLanguage } from "./languages.js";
+import { providerEntries } from "./provider-location.js";
 export const CONFIG_NAME = '.migraters.yaml';
 export const configPath = (dir) => join(dir, CONFIG_NAME);
-export const renderConfig = (language, dialects) => stringify({
+export const renderConfig = (language, dialects, configDir = '') => stringify({
     language,
-    dialects,
+    providers: providerEntries(language, dialects, configDir),
     binDir: binDirFor(language),
 });
 export const writeConfig = async (dir, language, dialects) => {
     const path = configPath(dir);
-    await writeFile(path, renderConfig(language, dialects));
+    await writeFile(path, renderConfig(language, dialects, dir));
+    if (language === 'typescript') {
+        const tsDir = join(dir, 'typescript');
+        if (existsSync(tsDir)) {
+            await writeFile(configPath(tsDir), renderConfig(language, dialects, tsDir));
+        }
+    }
     return path;
 };
 export const parseConfig = (raw) => {
     const doc = parse(raw);
-    const language = typeof doc?.language === 'string' ? normalizeLanguage(doc.language) : undefined;
-    if (!language) {
+    if (!doc || typeof doc.language !== 'string') {
         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 language = normalizeLanguage(doc.language);
+    if (!language) {
+        throw new Error(`${CONFIG_NAME} is missing a valid language`);
     }
+    const providers = parseProviders(doc);
     const binDir = typeof doc.binDir === 'string' && doc.binDir.length > 0 ? doc.binDir : binDirFor(language);
-    return { language, dialects: doc.dialects, binDir };
+    return { language, providers, binDir };
+};
+const parseProviders = (doc) => {
+    if (Array.isArray(doc.providers)) {
+        return doc.providers.map((item) => {
+            if (item &&
+                typeof item === 'object' &&
+                typeof item.name === 'string' &&
+                typeof item.location === 'string') {
+                return { name: item.name, location: item.location };
+            }
+            throw new Error(`${CONFIG_NAME} is missing a providers list`);
+        });
+    }
+    throw new Error(`${CONFIG_NAME} is missing a providers list`);
 };
 export const findConfigPath = (start, fallbackRoot) => {
     let dir = start;

package/orchestrator/dist/manifests.js

@@ -1,9 +1,9 @@
 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',
+    sqlite: 'Providers/Sqlite/MigrateSqlite.csproj',
+    postgres: 'Providers/Postgres/MigratePostgres.csproj',
+    mysql: 'Providers/Mysql/MigrateMysql.csproj',
+    sqlserver: 'Providers/SqlServer/MigrateSqlServer.csproj',
+    oracle: 'Providers/Oracle/MigrateOracle.csproj',
 };
 export const cargoDefaultFeaturesLine = (dialects) => `default = [${dialects.map((name) => `"${name}"`).join(', ')}]`;
 export const setCargoDefaultFeatures = (cargoToml, dialects) => {
@@ -25,7 +25,7 @@ export const setCargoDefaultFeatures = (cargoToml, dialects) => {
 };
 export const rustDialectCrate = (dialect) => `migraters-${dialect}`;
 export const rustDialectIdent = (dialect) => rustDialectCrate(dialect).replaceAll('-', '_');
-export const rustDialectPath = (dialect) => `dialects/${dialect}`;
+export const rustDialectPath = (dialect) => `providers/${dialect}`;
 export const renderAttachedDialects = (dialects) => [
     '// Generated by migrate-init. Do not edit.',
     '#![allow(unused_imports)]',

package/orchestrator/dist/provider-location.d.ts

@@ -0,0 +1,7 @@
+import type { Language } from './languages.ts';
+export type ProviderEntry = {
+    name: string;
+    location: string;
+};
+export declare const providerLocation: (language: Language, name: string, configDir?: string) => string;
+export declare const providerEntries: (language: Language, names: string[], configDir?: string) => ProviderEntry[];

package/orchestrator/dist/provider-location.js

@@ -0,0 +1,23 @@
+import { basename } from 'node:path';
+const csharpType = {
+    sqlite: { dll: 'MigrateSqlite.dll', type: 'Deterministic.MigrateRunner.SqliteProvider' },
+    postgres: { dll: 'MigratePostgres.dll', type: 'Deterministic.MigrateRunner.PostgresProvider' },
+    mysql: { dll: 'MigrateMysql.dll', type: 'Deterministic.MigrateRunner.MysqlProvider' },
+    sqlserver: { dll: 'MigrateSqlServer.dll', type: 'Deterministic.MigrateRunner.SqlServerProvider' },
+    oracle: { dll: 'MigrateOracle.dll', type: 'Deterministic.MigrateRunner.OracleProvider' },
+};
+export const providerLocation = (language, name, configDir = '') => {
+    if (language === 'csharp') {
+        const entry = csharpType[name];
+        if (!entry)
+            throw new Error(name);
+        return `${entry.dll}!${entry.type}`;
+    }
+    if (language === 'typescript') {
+        return basename(configDir) === 'typescript'
+            ? `providers/${name}/src/index.ts`
+            : `typescript/providers/${name}/src/index.ts`;
+    }
+    return `providers/${name}`;
+};
+export const providerEntries = (language, names, configDir = '') => names.map((name) => ({ name, location: providerLocation(language, name, configDir) }));

package/orchestrator/dist/run-init.js

@@ -10,7 +10,7 @@ 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 raw = await readFile(join(tsRoot, 'providers', dialect, 'package.json'), 'utf8');
         const pkg = JSON.parse(raw);
         for (const name of Object.keys(pkg.dependencies ?? {})) {
             if (!name.startsWith('@types/'))
@@ -22,7 +22,7 @@ const dialectRuntimeDeps = async (tsRoot, dialects) => {
 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));
+    const specs = dialects.map((name) => join(tsRoot, 'providers', name));
     if (specs.length > 0) {
         requireStatus(runCommand(npmCmd(), ['install', ...npmFlags, '--no-save', ...specs], { cwd: tsRoot }));
     }

package/orchestrator/prepare.js

@@ -5,6 +5,7 @@ import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 const orch = dirname(fileURLToPath(import.meta.url));
+const root = join(orch, '..');
 const src = join(orch, 'src', 'migrate-init.ts');
 const built = join(orch, 'dist', 'migrate-init.js');
 if (!existsSync(src)) {
@@ -14,8 +15,20 @@ if (!existsSync(src)) {
   }
   process.exit(0);
 }
-const result = spawnSync('npx', ['tsc', '-p', join(orch, 'tsconfig.json')], {
+const tsc = join(root, 'node_modules', 'typescript', 'bin', 'tsc');
+if (!existsSync(tsc)) {
+  process.stderr.write('typescript is not installed; run npm ci at the repo root\n');
+  process.exit(1);
+}
+const result = spawnSync(process.execPath, [tsc, '-p', join(orch, 'tsconfig.json')], {
   stdio: 'inherit',
-  shell: process.platform === 'win32',
 });
-process.exit(result.status ?? 1);
+if ((result.status ?? 1) !== 0) {
+  process.exit(result.status ?? 1);
+}
+const gitDir = join(root, '.git');
+const hooks = join(root, '.githooks');
+if (existsSync(src) && existsSync(gitDir) && existsSync(hooks)) {
+  spawnSync('git', ['config', 'core.hooksPath', '.githooks'], { cwd: root, stdio: 'ignore' });
+}
+process.exit(0);