@auto-engineer/file-store 0.1.2 → 0.1.3

package/src/LightningFileStore.specs.ts

@@ -1,109 +0,0 @@
-// @vitest-environment jsdom
-import { describe, it, expect, beforeEach } from 'vitest';
-import 'fake-indexeddb/auto';
-import { LightningFileStore } from './LightningFileStore';
-
-const te = new TextEncoder();
-const td = new TextDecoder();
-
-const resetIDBs = async () =>
-  await new Promise<void>((res, rej) => {
-    const dbs = ['flowfs-test', 'flowfs-complex-test'];
-    let done = 0;
-    for (const name of dbs) {
-      const req = indexedDB.deleteDatabase(name);
-      req.onerror = () => rej(req.error);
-      req.onsuccess = () => {
-        done += 1;
-        if (done === dbs.length) res();
-      };
-    }
-  });
-
-beforeEach(async () => {
-  await resetIDBs();
-});
-
-describe('LightningFS FileStore (basic ops)', () => {
-  it('writes and reads a file', async () => {
-    const fs = new LightningFileStore('flowfs-test');
-
-    await fs.write('/test.txt', te.encode('hello world'));
-    const buf = await fs.read('/test.txt');
-
-    expect(buf).not.toBeNull();
-    expect(td.decode(buf!)).toBe('hello world');
-  });
-
-  it('checks file existence', async () => {
-    const fs = new LightningFileStore('flowfs-test');
-
-    await fs.write('/exists.txt', te.encode('ok'));
-
-    expect(await fs.exists('/exists.txt')).toBe(true);
-    expect(await fs.exists('/missing.txt')).toBe(false);
-  });
-
-  it('supports nested directories (mkdir -p style) for write/read', async () => {
-    const fs = new LightningFileStore('flowfs-test');
-
-    await fs.write('/nested/deep/file.txt', te.encode('nested content'));
-    const buf = await fs.read('/nested/deep/file.txt');
-
-    expect(buf).not.toBeNull();
-    expect(td.decode(buf!)).toBe('nested content');
-  });
-
-  it('lists directory contents via listTree()', async () => {
-    const fs = new LightningFileStore('flowfs-test');
-
-    await fs.write('/a.txt', te.encode('a'));
-    await fs.write('/dir/b.txt', te.encode('b'));
-
-    const tree = await fs.listTree('/');
-
-    const paths = tree.map((e) => e.path).sort();
-    expect(paths).toContain('/');
-    expect(paths).toContain('/a.txt');
-    expect(paths).toContain('/dir');
-    expect(paths).toContain('/dir/b.txt');
-
-    const root = tree.find((e) => e.path === '/');
-    const dir = tree.find((e) => e.path === '/dir');
-    const file = tree.find((e) => e.path === '/a.txt');
-
-    expect(root?.type).toBe('dir');
-    expect(dir?.type).toBe('dir');
-    expect(file?.type).toBe('file');
-  });
-});
-
-describe('LightningFS FileStore (complex structure)', () => {
-  it('creates and verifies a multi-level project layout', async () => {
-    const fs = new LightningFileStore('flowfs-complex-test');
-
-    await fs.write('/src/flows/items.flow.ts', te.encode('items flow'));
-    await fs.write('/src/flows/orders.flow.ts', te.encode('orders flow'));
-    await fs.write('/src/integrations/user.integration.ts', te.encode('user integration'));
-    await fs.write('/config/settings.json', te.encode('{"key":"value"}'));
-
-    expect(await fs.exists('/src/flows/items.flow.ts')).toBe(true);
-    expect(await fs.exists('/src/flows/orders.flow.ts')).toBe(true);
-    expect(await fs.exists('/src/integrations/user.integration.ts')).toBe(true);
-    expect(await fs.exists('/config/settings.json')).toBe(true);
-
-    const tree = await fs.listTree('/src');
-    const paths = tree.map((e) => e.path);
-
-    expect(paths).toContain('/src');
-    expect(paths).toContain('/src/flows');
-    expect(paths).toContain('/src/integrations');
-    expect(paths).toContain('/src/flows/items.flow.ts');
-    expect(paths).toContain('/src/flows/orders.flow.ts');
-
-    // verify content
-    const itemsBuf = await fs.read('/src/flows/items.flow.ts');
-    expect(itemsBuf).not.toBeNull();
-    expect(td.decode(itemsBuf!)).toBe('items flow');
-  });
-});

package/src/LightningFileStore.ts

@@ -1,126 +0,0 @@
-import LightningFS from '@isomorphic-git/lightning-fs';
-import type { IFileStore } from './types';
-import { dirname } from './path';
-
-interface LightningFSStats {
-  isDirectory(): boolean;
-  size: number;
-}
-
-interface LightningFSPromises {
-  writeFile(path: string, data: Uint8Array): Promise<void>;
-  readFile(path: string): Promise<Uint8Array>;
-  stat(path: string): Promise<LightningFSStats>;
-  readdir(path: string): Promise<string[]>;
-  mkdir(path: string): Promise<void>;
-  unlink(path: string): Promise<void>;
-  rmdir(path: string): Promise<void>;
-}
-
-interface LightningFSInstance {
-  promises: LightningFSPromises;
-}
-
-export class LightningFileStore implements IFileStore {
-  private fs: LightningFSInstance;
-  private pfs: LightningFSPromises;
-
-  constructor(name = 'pocfs') {
-    this.fs = new LightningFS(name) as LightningFSInstance;
-    this.pfs = this.fs.promises;
-  }
-
-  async write(path: string, data: Uint8Array): Promise<void> {
-    await this.mkdirp(dirname(path));
-    await this.pfs.writeFile(path, data);
-  }
-
-  async read(path: string): Promise<Uint8Array | null> {
-    try {
-      return await this.pfs.readFile(path);
-    } catch {
-      return null;
-    }
-  }
-
-  async exists(path: string): Promise<boolean> {
-    return await this.pfs
-      .stat(path)
-      .then(() => true)
-      .catch(() => false);
-  }
-
-  async listTree(root: string = '/'): Promise<Array<{ path: string; type: 'file' | 'dir'; size: number }>> {
-    const out: Array<{ path: string; type: 'file' | 'dir'; size: number }> = [];
-    const walk = async (p: string) => {
-      let st: LightningFSStats | null = null;
-      try {
-        st = await this.pfs.stat(p);
-      } catch {
-        return;
-      }
-
-      if (st !== null && st.isDirectory()) {
-        out.push({ path: p, type: 'dir', size: 0 });
-        let entries: string[] = [];
-        try {
-          entries = await this.pfs.readdir(p);
-        } catch {
-          /* ignore */
-        }
-        for (const name of entries) {
-          const child = p === '/' ? `/${name}` : `${p}/${name}`;
-          await walk(child);
-        }
-      } else {
-        out.push({ path: p, type: 'file', size: st?.size ?? 0 });
-      }
-    };
-    await walk(root);
-    out.sort((a, b) => (a.type === b.type ? a.path.localeCompare(b.path) : a.type === 'dir' ? -1 : 1));
-    return out;
-  }
-
-  async remove(path: string): Promise<void> {
-    if (!path) return;
-    try {
-      const st = await this.pfs.stat(path);
-      if (st.isDirectory()) {
-        await this.removeDirectory(path);
-      } else {
-        await this.pfs.unlink(path);
-      }
-    } catch (err: unknown) {
-      if (this.isFileNotFoundError(err)) return;
-      throw err;
-    }
-  }
-
-  private async removeDirectory(path: string): Promise<void> {
-    const entries = await this.pfs.readdir(path).catch(() => []);
-    for (const name of entries) {
-      const child = path === '/' ? `/${name}` : `${path}/${name}`;
-      await this.remove(child);
-    }
-    await this.pfs.rmdir(path);
-  }
-
-  private isFileNotFoundError(err: unknown): boolean {
-    if (err instanceof Error && 'code' in err && err.code === 'ENOENT') return true;
-    return err === null || err === undefined;
-  }
-
-  private async mkdirp(path: string): Promise<void> {
-    if (!path || path === '/') return;
-    const parts = path.split('/').filter(Boolean);
-    let cur = '';
-    for (const part of parts) {
-      cur += '/' + part;
-      const exists = await this.pfs
-        .stat(cur)
-        .then(() => true)
-        .catch(() => false);
-      if (!exists) await this.pfs.mkdir(cur);
-    }
-  }
-}

package/src/text-helpers.ts

@@ -1,16 +0,0 @@
-export async function readText(
-  fs: { read(path: string): Promise<Uint8Array | null> },
-  path: string,
-): Promise<string | null> {
-  const buf = await fs.read(path);
-  return buf ? new TextDecoder().decode(buf) : null;
-}
-
-export async function writeText(
-  fs: { write(path: string, data: Uint8Array): Promise<void> },
-  path: string,
-  text: string,
-): Promise<void> {
-  const buf = new TextEncoder().encode(text);
-  await fs.write(path, buf);
-}