@crouton-kit/tsym 0.1.0

package/dist/store/store.js

@@ -0,0 +1,240 @@
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, unlinkSync, writeFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { NODE_TABLES, RELATION_TABLES, SCHEMA_STATEMENTS } from './schema.js';
+const ownedStores = new Set();
+const DEFAULT_BOUNDED_QUERY_TIMEOUT_MS = 30_000;
+const ENGINE_PLATFORMS = ['darwin-arm64', 'darwin-x64', 'linux-x64', 'linux-arm64', 'win32-x64'];
+const require = createRequire(import.meta.url);
+export class EngineBinaryError extends Error {
+    code = 'no-engine-binary';
+    platform;
+    constructor(platform = `${process.platform}-${process.arch}`) {
+        super(`LadybugDB has no prebuilt binary for ${platform}, and tsym does not compile it.\nPrebuilt platforms: ${ENGINE_PLATFORMS.join(', ')}.`);
+        this.platform = platform;
+    }
+}
+export class StoreOwnershipError extends Error {
+    storePath;
+    ownerPid;
+    constructor(storePath, ownerPid) {
+        super(ownerPid === undefined ? `The tsym store at ${storePath} is already open in this process.` : `The tsym store at ${storePath} is owned by process ${ownerPid}.`);
+        this.storePath = storePath;
+        this.ownerPid = ownerPid;
+        this.name = 'StoreOwnershipError';
+    }
+}
+export class StoreReadOnlyError extends Error {
+    constructor() {
+        super('Query statements must be read-only.');
+        this.name = 'StoreReadOnlyError';
+    }
+}
+export class Store {
+    path;
+    ownerPath;
+    database;
+    connection;
+    boundedConnection;
+    closed = false;
+    boundedQueryTimeoutMs;
+    constructor(storePath, options = {}) {
+        this.path = path.resolve(storePath);
+        this.boundedQueryTimeoutMs = options.boundedQueryTimeoutMs ?? DEFAULT_BOUNDED_QUERY_TIMEOUT_MS;
+        this.ownerPath = path.join(this.path, '.tsym-owner');
+        mkdirSync(this.path, { recursive: true, mode: 0o700 });
+        acquireOwnership(this.path, this.ownerPath);
+        try {
+            const { Database, Connection } = loadEngine();
+            this.database = new Database(path.join(this.path, 'graph.lbug'));
+            this.database.initSync();
+            this.connection = new Connection(this.database);
+            this.connection.initSync();
+            const tables = new Set(this.execute('CALL SHOW_TABLES() RETURN *').map((row) => row.name));
+            const expected = [...NODE_TABLES, ...RELATION_TABLES].map(tableName);
+            if (tables.size === 0)
+                this.transaction(() => { for (const statement of SCHEMA_STATEMENTS)
+                    this.execute(statement); });
+            else if (!expected.every((name) => tables.has(name)))
+                throw new Error(`Store schema is incomplete at ${this.path}.`);
+        }
+        catch (error) {
+            try {
+                this.connection?.closeSync();
+            }
+            catch { }
+            try {
+                this.database?.closeSync();
+            }
+            catch { }
+            releaseOwnership(this.path, this.ownerPath);
+            throw error;
+        }
+    }
+    execute(statement, parameters) {
+        this.assertOpen();
+        const connection = this.connection;
+        if (connection === undefined)
+            throw new Error('Store did not finish opening.');
+        const result = parameters === undefined
+            ? connection.querySync(statement)
+            : connection.executeSync(connection.prepareSync(statement), parameters);
+        return collect(result);
+    }
+    /** Executes a read query on a separate connection whose 30-second engine timeout never affects writes. */
+    executeBounded(statement, parameters) {
+        this.assertOpen();
+        const connection = this.bounded();
+        const prepared = connection.prepareSync(statement);
+        if (!prepared.isSuccess())
+            throw new Error(prepared.getErrorMessage());
+        if (!prepared.isReadOnly())
+            throw new StoreReadOnlyError();
+        return collect(connection.executeSync(prepared, parameters));
+    }
+    transaction(work) {
+        this.execute('BEGIN TRANSACTION');
+        try {
+            const value = work();
+            this.execute('COMMIT');
+            return value;
+        }
+        catch (error) {
+            try {
+                this.execute('ROLLBACK');
+            }
+            catch { }
+            throw error;
+        }
+    }
+    checkpoint() {
+        this.execute('CHECKPOINT');
+    }
+    close() {
+        if (this.closed)
+            return;
+        this.closed = true;
+        try {
+            this.boundedConnection?.closeSync();
+        }
+        finally {
+            try {
+                this.connection?.closeSync();
+            }
+            finally {
+                try {
+                    this.database?.closeSync();
+                }
+                finally {
+                    releaseOwnership(this.path, this.ownerPath);
+                }
+            }
+        }
+    }
+    bounded() {
+        if (this.boundedConnection !== undefined)
+            return this.boundedConnection;
+        const database = this.database;
+        if (database === undefined)
+            throw new Error('Store did not finish opening.');
+        const connection = new (loadEngine().Connection)(database);
+        connection.initSync();
+        connection.setQueryTimeout(this.boundedQueryTimeoutMs);
+        this.boundedConnection = connection;
+        return connection;
+    }
+    assertOpen() {
+        if (this.closed)
+            throw new Error('Store is closed.');
+    }
+}
+function loadEngine() {
+    let entry;
+    try {
+        entry = require.resolve('@ladybugdb/core');
+    }
+    catch {
+        throw new EngineBinaryError();
+    }
+    if (!existsSync(path.join(path.dirname(entry), 'lbugjs.node')))
+        throw new EngineBinaryError();
+    return require('@ladybugdb/core');
+}
+function tableName(statement) {
+    const match = /CREATE (?:NODE|REL) TABLE ([A-Za-z_][A-Za-z_]*)/.exec(statement);
+    if (!match)
+        throw new Error(`Schema statement has no table name: ${statement}`);
+    return match[1];
+}
+function collect(result) {
+    const results = Array.isArray(result) ? result : [result];
+    const rows = [];
+    for (const item of results) {
+        try {
+            rows.push(...item.getAllSync());
+        }
+        finally {
+            item.close();
+        }
+    }
+    return rows;
+}
+function acquireOwnership(storePath, ownerPath) {
+    if (ownedStores.has(storePath))
+        throw new StoreOwnershipError(storePath);
+    for (;;) {
+        try {
+            const fd = openSync(ownerPath, 'wx', 0o600);
+            try {
+                writeFileSync(fd, `${process.pid}\n`);
+            }
+            finally {
+                closeSync(fd);
+            }
+            ownedStores.add(storePath);
+            return;
+        }
+        catch (error) {
+            if (error.code !== 'EEXIST')
+                throw error;
+            const ownerPid = readOwnerPid(ownerPath);
+            if (ownerPid !== undefined && processAlive(ownerPid))
+                throw new StoreOwnershipError(storePath, ownerPid);
+            try {
+                unlinkSync(ownerPath);
+            }
+            catch (unlinkError) {
+                if (unlinkError.code !== 'ENOENT')
+                    throw unlinkError;
+            }
+        }
+    }
+}
+function releaseOwnership(storePath, ownerPath) {
+    ownedStores.delete(storePath);
+    try {
+        unlinkSync(ownerPath);
+    }
+    catch (error) {
+        if (error.code !== 'ENOENT')
+            throw error;
+    }
+}
+function readOwnerPid(ownerPath) {
+    try {
+        const value = Number.parseInt(readFileSync(ownerPath, 'utf8').trim(), 10);
+        return Number.isSafeInteger(value) && value > 0 ? value : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function processAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch (error) {
+        return error.code === 'EPERM';
+    }
+}

package/dist/ts7/api.d.ts

@@ -0,0 +1,35 @@
+import { type Project, type Snapshot } from 'typescript/unstable/sync';
+import type { UpdateSnapshotParams } from 'typescript/unstable/proto';
+export declare class TypeScriptBinaryError extends Error {
+    readonly code = "no-typescript-binary";
+    readonly platform: string;
+    constructor(platform?: string);
+}
+export declare class Ts7ServerDiedError extends Error {
+    constructor(cause: unknown);
+}
+/** Owns the one TypeScript 7 API client and its current snapshot for a resident. */
+export declare class Ts7Host {
+    readonly root: string;
+    private api;
+    private snapshot;
+    private configs;
+    /** Paths named by the most recent update; only these are read from disk, so unchanged files keep the server's native reads. */
+    private changed;
+    constructor(root: string);
+    get pid(): number | undefined;
+    /** Opens newly discovered configs and closes vanished ones; project opens are ref-counted, so each open needs its close. */
+    load(configs: readonly string[]): readonly Project[];
+    update(params: UpdateSnapshotParams): readonly Project[];
+    withSnapshot<T>(operation: (snapshot: Snapshot) => T): T;
+    sourceFile(config: string | undefined, file: string): import("typescript/unstable/ast").SourceFile | undefined;
+    close(): void;
+    private replaceSnapshot;
+    private request;
+    private recover;
+    private createApi;
+    private requireSnapshot;
+    private disposeSnapshot;
+}
+export declare function bundledTypeScriptVersion(): string;
+export declare function isBadFileDescriptor(error: unknown): boolean;

package/dist/ts7/api.js

@@ -0,0 +1,164 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import { API } from 'typescript/unstable/sync';
+import { resolveFileName } from 'typescript/unstable/proto';
+const require = createRequire(import.meta.url);
+export class TypeScriptBinaryError extends Error {
+    code = 'no-typescript-binary';
+    platform;
+    constructor(platform = `${process.platform}-${process.arch}`) {
+        super(`TypeScript has no prebuilt binary for ${platform}, and tsym does not compile it.`);
+        this.platform = platform;
+    }
+}
+export class Ts7ServerDiedError extends Error {
+    constructor(cause) {
+        super('The bundled TypeScript 7 API stopped responding.', { cause });
+    }
+}
+/** Owns the one TypeScript 7 API client and its current snapshot for a resident. */
+export class Ts7Host {
+    root;
+    api;
+    snapshot;
+    configs = [];
+    /** Paths named by the most recent update; only these are read from disk, so unchanged files keep the server's native reads. */
+    changed = new Set();
+    constructor(root) {
+        this.root = root;
+        this.api = this.createApi();
+    }
+    get pid() { return this.api.client.channel.child.pid; }
+    /** Opens newly discovered configs and closes vanished ones; project opens are ref-counted, so each open needs its close. */
+    load(configs) {
+        const open = new Set(this.configs);
+        const next = new Set(configs);
+        const openProjects = configs.filter((config) => !open.has(config));
+        const closeProjects = this.configs.filter((config) => !next.has(config));
+        this.configs = [...configs];
+        return this.replaceSnapshot({ openProjects, closeProjects }).getProjects();
+    }
+    update(params) {
+        this.changed = params.fileChanges && !('invalidateAll' in params.fileChanges)
+            ? new Set([...params.fileChanges.changed ?? [], ...params.fileChanges.created ?? [], ...params.fileChanges.deleted ?? []].map((file) => path.resolve(resolveFileName(file))))
+            : new Set();
+        return this.replaceSnapshot(params).getProjects();
+    }
+    withSnapshot(operation) {
+        return this.request(() => operation(this.requireSnapshot()));
+    }
+    sourceFile(config, file) {
+        const source = this.withSnapshot((snapshot) => config ? snapshot.getProject(config)?.program.getSourceFile(file) : snapshot.getDefaultProjectForFile(file)?.program.getSourceFile(file));
+        if (source || config)
+            return source;
+        this.replaceSnapshot({ openFiles: [file] });
+        return this.withSnapshot((snapshot) => snapshot.getDefaultProjectForFile(file)?.program.getSourceFile(file));
+    }
+    close() {
+        this.disposeSnapshot();
+        try {
+            this.api.close();
+        }
+        catch (error) {
+            if (!isBadFileDescriptor(error))
+                throw error;
+        }
+    }
+    replaceSnapshot(params) {
+        return this.request(() => {
+            const previous = this.snapshot;
+            const next = this.api.updateSnapshot(params);
+            this.snapshot = next;
+            if (previous) {
+                try {
+                    previous.dispose();
+                }
+                catch (error) {
+                    if (!isBadFileDescriptor(error))
+                        throw error;
+                }
+            }
+            return next;
+        });
+    }
+    request(operation) {
+        try {
+            return operation();
+        }
+        catch (error) {
+            if (!isBadFileDescriptor(error))
+                throw error;
+            this.recover();
+            try {
+                return operation();
+            }
+            catch (retryError) {
+                throw new Ts7ServerDiedError(retryError);
+            }
+        }
+    }
+    recover() {
+        this.disposeSnapshot();
+        try {
+            this.api.close();
+        }
+        catch (error) {
+            if (!isBadFileDescriptor(error))
+                throw error;
+        }
+        this.api = this.createApi();
+        if (this.configs.length > 0)
+            this.snapshot = this.api.updateSnapshot({ openProjects: [...this.configs] });
+    }
+    createApi() {
+        assertTypeScriptBinary();
+        return new API({ cwd: this.root, fs: { readFile: (file) => {
+                    if (!this.changed.has(path.resolve(file)))
+                        return undefined;
+                    try {
+                        return readFileSync(file, 'utf8');
+                    }
+                    catch (error) {
+                        if (error.code === 'ENOENT')
+                            return null;
+                        throw error;
+                    }
+                } } });
+    }
+    requireSnapshot() {
+        if (!this.snapshot)
+            throw new Error('TypeScript 7 projects have not been loaded.');
+        return this.snapshot;
+    }
+    disposeSnapshot() {
+        if (!this.snapshot)
+            return;
+        try {
+            this.snapshot.dispose();
+        }
+        catch (error) {
+            if (!isBadFileDescriptor(error))
+                throw error;
+        }
+        this.snapshot = undefined;
+    }
+}
+export function bundledTypeScriptVersion() {
+    return require('typescript/package.json').version;
+}
+function assertTypeScriptBinary() {
+    const packageName = `@typescript/typescript-${process.platform}-${process.arch}`;
+    try {
+        const packageJson = require.resolve(`${packageName}/package.json`);
+        const binary = path.join(path.dirname(packageJson), 'lib', process.platform === 'win32' ? 'tsc.exe' : 'tsc');
+        if (!existsSync(binary))
+            throw new Error('TypeScript native binary is absent.');
+    }
+    catch {
+        throw new TypeScriptBinaryError();
+    }
+}
+export function isBadFileDescriptor(error) {
+    return error instanceof Error && (/\bEBADF\b|bad file descriptor|Unexpected EOF while reading from child process/i.test(error.message) || error.code === 'EPIPE');
+}

package/dist/ts7/ast.d.ts

@@ -0,0 +1 @@
+export * from 'typescript/unstable/ast';

package/dist/ts7/ast.js

@@ -0,0 +1 @@
+export * from 'typescript/unstable/ast';

package/dist/ts7/checker.d.ts

@@ -0,0 +1,55 @@
+import { Ts7Host } from './api.js';
+import { ConfiguredProjects } from './projects.js';
+export interface TypeAnswer {
+    kind: string;
+    modifiers: string | undefined;
+    signature: string;
+    documentation: string;
+    tags: readonly {
+        name: string;
+        text: string;
+    }[];
+    definitions: readonly string[];
+}
+export interface CheckerDiagnostic {
+    file: string;
+    line: number;
+    column: number;
+    severity: string;
+    code: number;
+    message: string;
+}
+export interface RenameOccurrence {
+    file: string;
+    line: number;
+    col: number;
+}
+export interface CheckerRenameEdit extends RenameOccurrence {
+    startUtf16: number;
+    endUtf16: number;
+    oldText: string;
+    replacement: string;
+}
+export declare class RenamePreflightError extends Error {
+    readonly code: 'rename-through-string-literal' | 'rename-through-computed-name' | 'rename-outside-workspace' | 'rename-conflict';
+    readonly site: string;
+    constructor(code: 'rename-through-string-literal' | 'rename-through-computed-name' | 'rename-outside-workspace' | 'rename-conflict', site: string, message: string);
+}
+export declare function typeAt(host: Ts7Host, root: string, config: string, file: string, position: number, fallback: {
+    kind: string;
+    name: string;
+    address: string;
+}): TypeAnswer | null;
+export declare function diagnosticsForFiles(host: Ts7Host, root: string, scopes: readonly {
+    config: string;
+    files: readonly string[];
+}[]): CheckerDiagnostic[];
+/** Builds rename edits from indexed reference sites and rejects shapes TS7 cannot rewrite safely. */
+export declare function renameFromOccurrences(host: Ts7Host, root: string, projects: ConfiguredProjects, declaration: {
+    file: string;
+    nameSpan: {
+        start: number;
+    };
+    address: string;
+    name: string;
+}, occurrences: readonly RenameOccurrence[], newName: string): CheckerRenameEdit[];