wn-turso 0.1.0 → 0.2.0

package/dist/embedded-adapter-aWF095Qo.js

@@ -0,0 +1,92 @@
+import { createClient as e } from "@libsql/client";
+class s {
+  client;
+  connected = !1;
+  async initialize(t) {
+    if (!t.authToken)
+      throw new Error("authToken is required for remote Turso connections");
+    this.client = e({
+      url: t.url,
+      authToken: t.authToken
+    }), await this.client.execute("SELECT 1"), this.connected = !0;
+  }
+  getClient() {
+    if (!this.client)
+      throw new Error("Adapter not initialized");
+    return this.client;
+  }
+  getInfo() {
+    return {
+      mode: "remote",
+      connected: this.connected
+    };
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async close() {
+    this.client && (this.client.close(), this.connected = !1);
+  }
+  getName() {
+    return "remote-turso";
+  }
+}
+class c {
+  client;
+  config;
+  connected = !1;
+  lastSync;
+  syncStatus = "pending";
+  async initialize(t) {
+    this.config = t, this.client = e({
+      url: t.url,
+      // Local file path: file:./local.db
+      syncUrl: t.syncUrl,
+      authToken: t.authToken,
+      encryptionKey: t.encryptionKey
+    }), t.syncUrl && t.authToken && await this.sync(), this.connected = !0;
+  }
+  getClient() {
+    if (!this.client)
+      throw new Error("Adapter not initialized");
+    return this.client;
+  }
+  getInfo() {
+    return {
+      mode: "embedded",
+      connected: this.connected,
+      syncStatus: this.syncStatus,
+      lastSync: this.lastSync
+    };
+  }
+  isConnected() {
+    return this.connected;
+  }
+  async close() {
+    if (this.client) {
+      if (this.config?.syncUrl)
+        try {
+          await this.sync();
+        } catch (t) {
+          console.warn("Failed to sync before close:", t);
+        }
+      this.client.close(), this.connected = !1;
+    }
+  }
+  getName() {
+    return "embedded-turso";
+  }
+  async sync() {
+    if (!this.client)
+      throw new Error("Adapter not initialized");
+    try {
+      await this.client.sync(), this.lastSync = /* @__PURE__ */ new Date(), this.syncStatus = "synced";
+    } catch (t) {
+      throw this.syncStatus = "error", t;
+    }
+  }
+}
+export {
+  c as E,
+  s as R
+};

package/dist/index.d.ts

@@ -1,11 +1,2 @@
-/**
- * wn-turso - Turso/libsql database backend and data pipeline utilities for WordNet
- *
- * @packageDocumentation
- */
-export { TursoWordnet, type TursoWordnetOptions } from './wordnet/index.js';
-export { TursoDatabase, TursoQueryService, createTursoDialect, TursoDriver, TursoConnection, type Database, } from './database/index.js';
-export { RemoteTursoAdapter, EmbeddedTursoAdapter, type TursoAdapter, type TursoAdapterInfo, } from './adapters/index.js';
-export { type TursoDatabaseConfig, type TursoConnectionMode, type SyncConfig, defaultSyncConfig, validateTursoConfig, } from './config.js';
-export { Pipeline } from './pipeline/index.js';
-//# sourceMappingURL=index.d.ts.map
+export * from './src/index'
+export {}

package/dist/index.js

@@ -1,15 +1,96 @@
-/**
- * wn-turso - Turso/libsql database backend and data pipeline utilities for WordNet
- *
- * @packageDocumentation
- */
-// Main WordNet class
-export { TursoWordnet } from './wordnet/index.js';
-// Database components
-export { TursoDatabase, TursoQueryService, createTursoDialect, TursoDriver, TursoConnection, } from './database/index.js';
-// Adapters
-export { RemoteTursoAdapter, EmbeddedTursoAdapter, } from './adapters/index.js';
-// Configuration
-export { defaultSyncConfig, validateTursoConfig, } from './config.js';
-// Pipeline (re-export from subpath for convenience)
-export { Pipeline } from './pipeline/index.js';
+import { T as s } from "./turso-database-CNWM_LV6.js";
+import { d, b as u, a as y, c as h } from "./turso-database-CNWM_LV6.js";
+import { E as b, R as l } from "./embedded-adapter-aWF095Qo.js";
+import { defaultSyncConfig as w, validateTursoConfig as m } from "./config.js";
+import { P as p } from "./pipeline-builder-ERaxT48h.js";
+class n {
+  database;
+  config;
+  constructor(e, t = {}) {
+    this.config = e;
+  }
+  /**
+   * Initialize the WordNet connection
+   */
+  async initialize() {
+    this.database = new s(this.config), await this.database.initialize();
+  }
+  /**
+   * Query synsets
+   */
+  async synsets(e) {
+    return this.getQueryService().getSynsets(e);
+  }
+  /**
+   * Query words
+   */
+  async words(e) {
+    return this.getQueryService().getWords(e);
+  }
+  /**
+   * Query senses
+   */
+  async senses(e) {
+    return this.getQueryService().getSenses(e);
+  }
+  /**
+   * Get all lexicons
+   */
+  async lexicons() {
+    return this.getQueryService().getLexicons();
+  }
+  /**
+   * Get lemmas for a synset
+   */
+  async getSynsetLemmas(e) {
+    return (await this.getQueryService().getWordsBySynsetAndLanguage(
+      e
+    )).map((a) => a.lemma);
+  }
+  /**
+   * Sync embedded replica with remote (only for embedded mode)
+   */
+  async sync() {
+    if (!this.database)
+      throw new Error("Not initialized");
+    await this.database.sync();
+  }
+  /**
+   * Check if initialized
+   */
+  isInitialized() {
+    return this.database?.isInitialized() ?? !1;
+  }
+  /**
+   * Close the connection
+   */
+  async close() {
+    this.database && (await this.database.close(), this.database = void 0);
+  }
+  /**
+   * Get the underlying database instance
+   */
+  getDatabase() {
+    if (!this.database)
+      throw new Error("Not initialized");
+    return this.database;
+  }
+  getQueryService() {
+    if (!this.database)
+      throw new Error("Not initialized");
+    return this.database.getQueryService();
+  }
+}
+export {
+  b as EmbeddedTursoAdapter,
+  p as Pipeline,
+  l as RemoteTursoAdapter,
+  d as TursoConnection,
+  s as TursoDatabase,
+  u as TursoDriver,
+  y as TursoQueryService,
+  n as TursoWordnet,
+  h as createTursoDialect,
+  w as defaultSyncConfig,
+  m as validateTursoConfig
+};

package/dist/pipeline-builder-ERaxT48h.js

@@ -0,0 +1,275 @@
+function a(s) {
+  return async function* (t) {
+    for await (const n of t)
+      s(n) && (yield n);
+  };
+}
+function e(s) {
+  return async function* (t) {
+    for await (const n of t)
+      yield s(n);
+  };
+}
+function c(s) {
+  return async function* (t) {
+    for await (const n of t) {
+      const o = s(n);
+      o != null && (yield o);
+    }
+  };
+}
+function u(s) {
+  return async function* (t) {
+    for await (const n of t) {
+      const o = await s(n);
+      o != null && (yield o);
+    }
+  };
+}
+function f(s) {
+  return async function* (t) {
+    for await (const n of t) {
+      const o = s(n);
+      yield { ...n, ...o };
+    }
+  };
+}
+function h(s) {
+  return async function* (t) {
+    for await (const n of t) {
+      const o = await s(n);
+      yield { ...n, ...o };
+    }
+  };
+}
+function w(s) {
+  return async function* (t) {
+    let n = [];
+    for await (const o of t)
+      n.push(o), n.length >= s && (yield n, n = []);
+    n.length > 0 && (yield n);
+  };
+}
+function b() {
+  return async function* (s) {
+    for await (const t of s)
+      for (const n of t)
+        yield n;
+  };
+}
+function y(s) {
+  return async function* (t) {
+    for await (const n of t)
+      s(n), yield n;
+  };
+}
+function p(s) {
+  return async function* (t) {
+    for await (const n of t)
+      await s(n), yield n;
+  };
+}
+function l(s) {
+  return async function* (t) {
+    let n = 0;
+    for await (const o of t) {
+      if (n >= s) break;
+      yield o, n++;
+    }
+  };
+}
+function d(s) {
+  return async function* (t) {
+    let n = 0;
+    for await (const o of t)
+      n >= s && (yield o), n++;
+  };
+}
+function m(s) {
+  return async function* (t) {
+    const n = /* @__PURE__ */ new Set();
+    for await (const o of t) {
+      const r = s(o);
+      n.has(r) || (n.add(r), yield o);
+    }
+  };
+}
+function A(...s) {
+  return (t) => s.reduce((n, o) => o(n), t);
+}
+class i {
+  // Internal state uses unknown for type erasure - public API maintains type safety
+  source;
+  operations = [];
+  constructor(t) {
+    this.source = t;
+  }
+  /**
+   * Create a new pipeline from a source
+   */
+  static from(t) {
+    return new i(t);
+  }
+  /**
+   * Filter rows based on a predicate
+   */
+  filter(t) {
+    return this.operations.push(
+      a(t)
+    ), this;
+  }
+  /**
+   * Map rows to a new shape
+   */
+  map(t) {
+    return this.operations.push(e(t)), this;
+  }
+  /**
+   * Transform rows, returning null to skip a row
+   */
+  transform(t) {
+    return this.operations.push(c(t)), this;
+  }
+  /**
+   * Async transform for operations that need to await
+   */
+  transformAsync(t) {
+    return this.operations.push(
+      u(t)
+    ), this;
+  }
+  /**
+   * Extend rows with additional properties
+   * Useful for adding columns to a "working DB" schema
+   */
+  extend(t) {
+    return this.operations.push(
+      f(
+        t
+      )
+    ), this;
+  }
+  /**
+   * Async extend for operations that need to await
+   */
+  extendAsync(t) {
+    return this.operations.push(
+      h(
+        t
+      )
+    ), this;
+  }
+  /**
+   * Batch rows into arrays
+   */
+  batch(t) {
+    return this.operations.push(w(t)), this;
+  }
+  /**
+   * Side effect for each row (logging, metrics)
+   */
+  tap(t) {
+    return this.operations.push(y(t)), this;
+  }
+  /**
+   * Async side effect
+   */
+  tapAsync(t) {
+    return this.operations.push(p(t)), this;
+  }
+  /**
+   * Take first n rows
+   */
+  take(t) {
+    return this.operations.push(l(t)), this;
+  }
+  /**
+   * Skip first n rows
+   */
+  skip(t) {
+    return this.operations.push(d(t)), this;
+  }
+  /**
+   * Deduplicate rows by key
+   */
+  distinct(t) {
+    return this.operations.push(
+      m(t)
+    ), this;
+  }
+  /**
+   * Build the pipeline as an async iterable
+   * Useful for manual iteration or custom sinks
+   */
+  build() {
+    let t = this.source.read();
+    for (const n of this.operations)
+      t = n(t);
+    return t;
+  }
+  /**
+   * Execute the pipeline and write to a sink
+   */
+  async to(t) {
+    const n = this.build();
+    return t.write(n);
+  }
+  /**
+   * Execute the pipeline and collect results into an array
+   */
+  async toArray() {
+    const t = [], n = this.build();
+    for await (const o of n)
+      t.push(o);
+    return t;
+  }
+  /**
+   * Count the rows that pass through the pipeline
+   */
+  async count() {
+    let t = 0;
+    const n = this.build();
+    for await (const o of n)
+      t++;
+    return t;
+  }
+  /**
+   * Execute a function for each row
+   */
+  async forEach(t) {
+    const n = this.build();
+    for await (const o of n)
+      t(o);
+  }
+  /**
+   * Execute an async function for each row
+   */
+  async forEachAsync(t) {
+    const n = this.build();
+    for await (const o of n)
+      await t(o);
+  }
+  /**
+   * Get the source count (if available)
+   */
+  async sourceCount() {
+    return this.source.count?.();
+  }
+}
+export {
+  i as P,
+  u as a,
+  h as b,
+  w as c,
+  y as d,
+  f as e,
+  a as f,
+  p as g,
+  l as h,
+  m as i,
+  A as j,
+  e as m,
+  d as s,
+  c as t,
+  b as u
+};

package/dist/pipeline.d.ts

@@ -0,0 +1,2 @@
+export * from './src/pipeline/index'
+export {}

package/dist/pipeline.js

@@ -0,0 +1,189 @@
+import { P as q, c as P, j as v, i as C, e as N, b as j, f as I, m as M, s as O, h as R, d as E, g as G, t as H, a as J, u as K } from "./pipeline-builder-ERaxT48h.js";
+import { T as m } from "./turso-database-CNWM_LV6.js";
+async function* p(t, r, a = {}) {
+  const { batchSize: e = 1e3, where: n, orderBy: i, limit: c, offset: y = 0 } = a;
+  let l = y, u = !0, f = 0;
+  for (; u; ) {
+    let s = t.selectFrom(r).selectAll();
+    n && (s = n(s)), i && (s = s.orderBy(i)), s = s.limit(e).offset(l);
+    const o = await s.execute();
+    if (o.length === 0) {
+      u = !1;
+      break;
+    }
+    for (const w of o)
+      if (yield w, f++, c !== void 0 && f >= c) {
+        u = !1;
+        break;
+      }
+    o.length < e && (u = !1), l += e;
+  }
+}
+async function b(t, r, a, e = {}) {
+  const { batchSize: n = 100, onConflict: i = "error", onProgress: c } = e, y = Date.now();
+  let l = 0, u = 0, f = 0, s = 0, o = [];
+  const w = async () => {
+    if (o.length !== 0) {
+      try {
+        let h = t.insertInto(r).values(o);
+        (i === "ignore" || i === "replace") && (h = h.onConflict((D) => D.doNothing())), await h.execute(), u += o.length;
+      } catch (d) {
+        if (i === "error")
+          throw d;
+        s += o.length;
+      }
+      o = [];
+    }
+  };
+  for await (const d of a)
+    o.push(d), l++, o.length >= n && (await w(), c && c({
+      current: l,
+      processed: l,
+      skipped: f,
+      errors: s
+    }));
+  return await w(), {
+    processed: l,
+    inserted: u,
+    skipped: f,
+    errors: s,
+    duration: Date.now() - y
+  };
+}
+async function k(t, r, a = {}) {
+  const { where: e } = a;
+  let i = t.selectFrom(r).select((y) => y.fn.countAll().as("count"));
+  e && (i = e(i));
+  const c = await i.executeTakeFirst();
+  return Number(c?.count ?? 0);
+}
+function S(t, r, a = {}) {
+  return {
+    name: `turso:${t.url}/${r}`,
+    async *read() {
+      const e = new m(t);
+      await e.initialize();
+      try {
+        yield* p(
+          e.getDatabase(),
+          r,
+          a
+        );
+      } finally {
+        await e.close();
+      }
+    },
+    async count() {
+      const e = new m(t);
+      await e.initialize();
+      try {
+        return await k(
+          e.getDatabase(),
+          r,
+          a
+        );
+      } finally {
+        await e.close();
+      }
+    }
+  };
+}
+function x(t, r, a = {}) {
+  return {
+    name: `kysely:${r}`,
+    async *read() {
+      yield* p(t, r, a);
+    },
+    async count() {
+      return k(t, r, a);
+    }
+  };
+}
+function T(t, r = "array") {
+  return {
+    name: r,
+    async *read() {
+      for (const a of t)
+        yield a;
+    },
+    async count() {
+      return t.length;
+    }
+  };
+}
+function $(t, r, a = {}) {
+  return {
+    name: `turso:${t.url}/${r}`,
+    async write(e) {
+      const n = new m({
+        ...t,
+        readonly: !1
+        // Ensure we can write
+      });
+      await n.initialize();
+      try {
+        return await b(
+          n.getDatabase(),
+          r,
+          e,
+          a
+        );
+      } finally {
+        await n.close();
+      }
+    }
+  };
+}
+function z(t, r, a = {}) {
+  return {
+    name: `kysely:${r}`,
+    async write(e) {
+      return b(t, r, e, a);
+    }
+  };
+}
+function A() {
+  const t = [], r = Date.now();
+  return {
+    name: "array",
+    items: t,
+    async write(a) {
+      let e = 0;
+      for await (const n of a)
+        t.push(n), e++;
+      return {
+        processed: e,
+        inserted: e,
+        skipped: 0,
+        errors: 0,
+        duration: Date.now() - r
+      };
+    }
+  };
+}
+export {
+  q as Pipeline,
+  A as arraySink,
+  T as arraySource,
+  P as batch,
+  v as compose,
+  k as countRows,
+  C as distinct,
+  N as extend,
+  j as extendAsync,
+  I as filter,
+  z as kyselySink,
+  x as kyselySource,
+  M as map,
+  O as skip,
+  p as streamTable,
+  R as take,
+  E as tap,
+  G as tapAsync,
+  H as transform,
+  J as transformAsync,
+  $ as tursoSink,
+  S as tursoSource,
+  K as unbatch,
+  b as writeBatches
+};

package/dist/{adapters → src/adapters}/adapter.d.ts

@@ -1,8 +1,5 @@
-/**
- * Turso adapter interface
- */
-import type { Client } from '@libsql/client';
-import type { TursoDatabaseConfig } from '../config.js';
+import { Client } from '@libsql/client';
+import { TursoDatabaseConfig } from '../config.js';
 /**
  * Adapter status information
  */

package/dist/src/adapters/adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"adapter.d.ts","sourceRoot":"","sources":["../../../src/adapters/adapter.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,cAAc,CAAC;AAExD;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,mBAAmB;IACnB,IAAI,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC5B,oCAAoC;IACpC,SAAS,EAAE,OAAO,CAAC;IACnB,sCAAsC;IACtC,UAAU,CAAC,EAAE,QAAQ,GAAG,SAAS,GAAG,OAAO,CAAC;IAC5C,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,IAAI,CAAC;CACjB;AAED;;;GAGG;AACH,MAAM,WAAW,YAAY;IAC3B;;OAEG;IACH,UAAU,CAAC,MAAM,EAAE,mBAAmB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvD;;OAEG;IACH,SAAS,IAAI,MAAM,CAAC;IAEpB;;OAEG;IACH,OAAO,IAAI,gBAAgB,CAAC;IAE5B;;OAEG;IACH,WAAW,IAAI,OAAO,CAAC;IAEvB;;OAEG;IACH,KAAK,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;IAEvB;;OAEG;IACH,OAAO,IAAI,MAAM,CAAC;IAElB;;OAEG;IACH,IAAI,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACxB"}

package/dist/{adapters → src/adapters}/embedded-adapter.d.ts

@@ -1,9 +1,6 @@
-/**
- * Embedded Turso adapter - Local SQLite with sync
- */
-import { type Client } from '@libsql/client';
-import type { TursoDatabaseConfig } from '../config.js';
-import type { TursoAdapter, TursoAdapterInfo } from './adapter.js';
+import { Client } from '@libsql/client';
+import { TursoDatabaseConfig } from '../config.js';
+import { TursoAdapter, TursoAdapterInfo } from './adapter.js';
 /**
  * Embedded Turso adapter for local SQLite with optional sync
  */