@alexmitchell/melondb 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Alzen
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -1,3 +1,486 @@
-# Temporary Holding Version
+# 🍈 MelonDB
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Typed helpers for [WatermelonDB](https://github.com/Nozbe/WatermelonDB).
+
+MelonDB is WatermelonDB but more DRY. WatermelonDB is excellent for building offline-first React Native apps. **MelonDB** improves the developer experience by wrapping common operations in a small, typed API you configure once per app, reducing boilerplate and making simple mistakes easier to catch.
+
+---
+
+## Install
+
+```bash
+npm install @alexmitchell/melondb @nozbe/watermelondb
+```
+
+```bash
+yarn add @alexmitchell/melondb @nozbe/watermelondb
+```
+
+`@nozbe/watermelondb` (>= 0.27) and `react` (>= 18) are **peer dependencies**: MelonDB uses your app's copy rather than bundling its own. If you've already set up WatermelonDB you have both.
+
+---
+
+## Quick start
+
+Suppose you have some note data to insert:
+
+```ts
+const draft = {
+  title: "Hello",
+  body: "World",
+  // ...
+};
+```
+
+With **WatermelonDB**, creating the row looks like this:
+
+```ts
+const noteId = await database.write(async () => {
+  const note = await database.get<NoteModel>("notes").create((record) => {
+    record.title = draft.title;
+    record.body = draft.body;
+    // ...
+  });
+  return note.id;
+});
+```
+
+Once [configured](#setup), **MelonDB** reduces the same operation to:
+
+```ts
+const noteId = await melon.insert("notes", draft);
+```
+
+WatermelonDB requires each field to be assigned manually. TypeScript can catch a wrong type when it is assigned to a typed model property, but it does not check `draft` as a complete `notes` payload at the database call. A missing assignment is easy to overlook, and the `"notes"` string is not tied to the `NoteModel` type argument.
+
+MelonDB uses `"notes"` to infer `TableData["notes"]`, then checks `draft` against it. A missing required property or a value with the wrong type—such as `body: 123`—causes a TypeScript error at the `insert` call. An unknown table name is rejected too.
+
+---
+
+## Setup
+
+### Define your tables
+
+You still define each model and schema the WatermelonDB way. MelonDB only replaces the repetitive database access layer.
+
+```ts
+import { Model, tableSchema } from "@nozbe/watermelondb";
+import { text, readonly, date } from "@nozbe/watermelondb/decorators";
+
+class NoteModel extends Model {
+  static table = "notes";
+
+  @text("title") title!: string;
+  @text("body") body!: string;
+  @readonly @date("created_at") createdAt!: Date;
+}
+
+type Note = Omit<NoteModel, keyof Model>;
+
+const noteSchema = tableSchema({
+  name: "notes",
+  columns: [
+    { name: "title", type: "string" },
+    { name: "body", type: "string" },
+    { name: "created_at", type: "number" },
+  ],
+});
+```
+
+### Initialize MelonDB
+
+Then register your tables once in the app-wide configuration:
+
+```ts
+import { createMelon } from "@alexmitchell/melondb";
+
+// Register every table in these app-wide definitions.
+
+type TableModels = {
+  notes: NoteModel;
+  // ...
+};
+
+type TableData = {
+  notes: Note;
+  // ...
+};
+
+const tables = [
+  noteSchema,
+  // ...
+];
+
+const modelClasses = [
+  NoteModel,
+  // ...
+];
+
+export const melon = createMelon<TableModels, TableData>({
+  version: 1,
+  tables,
+  modelClasses,
+  migrations: [],
+});
+```
+
+That gives you a typed `melon` instance plus the underlying `melon.db` if you need raw WatermelonDB APIs.
+
+---
+
+## More examples
+
+### Batch create
+
+Suppose you have several notes to insert:
+
+```ts
+const rows = [
+  { title: "One", body: "..." },
+  { title: "Two", body: "..." },
+  // ...
+];
+```
+
+**WatermelonDB**
+
+```ts
+await database.write(async () => {
+  const collection = database.get<NoteModel>("notes");
+  const prepared = rows.map((row) =>
+    collection.prepareCreate((record) => {
+      record.title = row.title;
+      record.body = row.body;
+    }),
+  );
+  await database.batch(prepared);
+});
+```
+
+**MelonDB**
+
+```ts
+await melon.insertBatch("notes", rows);
+```
+
+---
+
+### Fetch one row by id
+
+WatermelonDB's `find` rejects if the row does not exist, so returning `null` instead requires handling that error yourself.
+
+**WatermelonDB**
+
+```ts
+let note: NoteModel | null = null;
+try {
+  note = await database.get<NoteModel>("notes").find(id);
+} catch {
+  note = null;
+}
+```
+
+**MelonDB**
+
+```ts
+const note = await melon.getRowById("notes", id); // NoteModel | null
+```
+
+MelonDB handles the missing-row case and returns `null`. It also infers `NoteModel` from the `"notes"` table name, so the string and model type cannot drift apart.
+
+---
+
+### Update one field
+
+Updating a single column on a single row is a common operation. Suppose you want to rename a note:
+
+```ts
+const newTitle = "Renamed";
+```
+
+**WatermelonDB**
+
+```ts
+await database.write(async () => {
+  await note.update((row) => {
+    row.title = newTitle;
+    // easy to forget a convention like updatedDate
+  });
+});
+```
+
+**MelonDB**
+
+```ts
+await melon.updateColumn(note, "title", newTitle);
+```
+
+`updateColumn` ties the property name to that property's value type. Because `title` is a string, TypeScript would flag `newTitle` if it were a number. If the model has an `updatedDate` property, MelonDB also sets it to `new Date().toISOString()` automatically.
+
+For several fields:
+
+```ts
+await melon.updateColumns(note, [
+  { property: "title", value: "Renamed" },
+  { property: "body", value: "New body" },
+]);
+```
+
+Or a full updater when you need custom logic:
+
+```ts
+await melon.updateRow(note, (row) => {
+  row.title = row.title.trim();
+});
+```
+
+---
+
+### Soft-delete
+
+WatermelonDB deletes model instances rather than IDs. If all you have is `noteId`, you must fetch the row before you can delete it:
+
+**WatermelonDB**
+
+```ts
+const note = await database.get<NoteModel>("notes").find(noteId);
+
+await database.write(async () => {
+  await note.markAsDeleted();
+});
+```
+
+**MelonDB**
+
+```ts
+await melon.deleteRowById("notes", noteId);
+```
+
+`deleteRowById` performs the lookup and soft-delete for you. If you already have the model instance, use `melon.deleteRow(note)` instead.
+
+---
+
+### Typed collections
+
+**WatermelonDB**
+
+```ts
+const notes = database.get<NoteModel>("notes");
+// table name is a free string; generics are easy to drift
+```
+
+**MelonDB**
+
+```ts
+const notes = melon.get("notes");
+// Collection<NoteModel> — table name is keyed by TableModels
+```
+
+---
+
+### Observable components (`withObservables`)
+
+WatermelonDB's `withObservables` HOC is powerful but awkward to type when you also have query props and extra component props.
+
+**WatermelonDB** (common pattern: cast and hope)
+
+```ts
+export default withObservables(["noteId"], ({ noteId }) => ({
+  note: database.get("notes").findAndObserve(noteId),
+}))(NoteBody) as React.ComponentType<{ noteId: string }>;
+```
+
+**MelonDB**
+
+```ts
+type Injected = { note: NoteModel };
+type Query = { noteId: string };
+type Props = { showTimestamp: boolean };
+
+const enhancer = withObservables(["noteId"], ({ noteId }: Query) => ({
+  note: melon.get("notes").findAndObserve(noteId),
+}));
+
+export default melon.enhance<Injected, Query, Props>(enhancer, NoteBody);
+// ComponentType<{ noteId: string; showTimestamp: boolean }>
+```
+
+`enhance` is a thin typing helper: it wires `Injected` (from the HOC), `Query` (inputs that drive observables), and optional extra `Props` without fighting the HOC generics by hand.
+
+---
+
+### Safe database reset
+
+Calling `unsafeResetDatabase` while React components still observe the DB can crash (see [WatermelonDB #102](https://github.com/Nozbe/WatermelonDB/issues/102)).
+
+**WatermelonDB**
+
+```ts
+// You must coordinate unmounting observers yourself, then:
+await database.write(async () => {
+  await database.unsafeResetDatabase();
+});
+```
+
+**MelonDB**
+
+```ts
+// Gate UI on availability:
+const available = useSyncExternalStore(
+  melon.subscribeDatabaseAvailable,
+  melon.getDatabaseAvailable,
+  melon.getDatabaseAvailable,
+);
+
+if (!available) return null;
+
+// Later, after a schema bump or logout:
+await melon.resetDatabase();
+```
+
+`resetDatabase` sets availability to `false`, waits for React to unmount gated observers, resets, then sets availability back to `true`.
+
+---
+
+## Platform adapters
+
+`createMelon` / `createWatermelon` pick an adapter automatically:
+
+| Platform      | Adapter                                     |
+| ------------- | ------------------------------------------- |
+| iOS / Android | SQLite (`createAdapter.ts`)                 |
+| Web           | LokiJS + IndexedDB (`createAdapter.web.ts`) |
+
+Metro and webpack resolve the `.web.ts` file on web. You do not need to branch this yourself.
+
+---
+
+## IDs
+
+By default, MelonDB leaves WatermelonDB's own random id generator in place. Pass `idGenerator` to replace it globally:
+
+```ts
+createMelon({
+  // ...schema
+  idGenerator: () => myCustomId(),
+});
+```
+
+See [Tips → UUID v7 ids](#uuid-v7-ids) for a common choice.
+
+---
+
+## Logging
+
+On by default. MelonDB logs to the console (prefixed `[🍈 MelonDB]`) when `getRowById` fails and when `resetDatabase` completes. To turn that off:
+
+```ts
+createMelon({
+  // ...schema
+  logging: false,
+});
+```
+
+`logRowCount` and `logAllRows` always print, since calling them is an explicit request for output.
+
+---
+
+## Exporting plain rows
+
+When you need JSON without WatermelonDB meta (`_status`, `_changed`):
+
+```ts
+import { cleanRow } from "@alexmitchell/melondb";
+
+const plain = cleanRow()(note);
+// or merge extra fields:
+const withUser = cleanRow({ user_id: userId })(note);
+```
+
+For debug logging of model instances (circular refs):
+
+```ts
+import { sanitizeCircular } from "@alexmitchell/melondb";
+
+console.log(JSON.stringify(sanitizeCircular(note)));
+```
+
+---
+
+## API summary
+
+| Method                                  | Purpose                     |
+| --------------------------------------- | --------------------------- |
+| `melon.db`                              | Raw WatermelonDB `Database` |
+| `melon.get(table)`                      | Typed `Collection`          |
+| `melon.getRowById(table, id)`           | Fetch one or `null`         |
+| `melon.insert(table, data)`             | Create, return id           |
+| `melon.insertBatch(table, rows)`        | Batch create                |
+| `melon.updateRow(model, fn)`            | Update with updater         |
+| `melon.updateColumn(model, key, value)` | Single-field update         |
+| `melon.updateColumns(model, cols)`      | Multi-field update          |
+| `melon.deleteRow(model)`                | Soft-delete                 |
+| `melon.deleteRowById(table, id)`        | Soft-delete by id           |
+| `melon.deleteBatch(models)`             | Soft-delete many            |
+| `melon.deleteTable(table)`              | Soft-delete all rows        |
+| `melon.emptyTable(table)`               | Permanent destroy all       |
+| `melon.getRowCount(table)`              | Count                       |
+| `melon.logRowCount` / `logAllRows`      | Debug helpers               |
+| `melon.enhance(hoc, Component)`         | Typed `withObservables`     |
+| `melon.resetDatabase()`                 | Safe reset                  |
+| `melon.getDatabaseAvailable()`          | Current availability flag   |
+| `melon.subscribeDatabaseAvailable(fn)`  | Subscribe to that flag      |
+
+Also exported: `createWatermelon`, `createAdapter`, `cleanRow`, `sanitizeCircular`.
+
+---
+
+## Type parameters
+
+```ts
+createMelon<TableModels, TableData>({ ... })
+```
+
+- `**TableModels**`: map table name → Model class instance type
+- `**TableData**`: map table name → plain object shape for `insert` / `insertBatch`
+
+Keep those two maps in sync with your schema and you get end-to-end typing for table names and insert payloads.
+
+---
+
+## What this is not
+
+- Not a sync engine. No pull/push, no backend protocol.
+- Not a replacement for WatermelonDB models, schemas, migrations, or queries.
+- Not a full ORM. Prefer `melon.get(table).query(...)` when you need WatermelonDB's query API.
+
+---
+
+## Tips
+
+### UUID v7 ids
+
+WatermelonDB's default ids are short random strings. If you sync with a backend that uses UUID primary keys, time-ordered UUID v7 ids are a good fit: they sort by creation time and index well in Postgres.
+
+```bash
+npm install uuid react-native-get-random-values
+```
+
+```ts
+import "react-native-get-random-values"; // must run before uuid, polyfills crypto.getRandomValues on React Native
+import { v7 as uuidv7 } from "uuid";
+import { createMelon } from "@alexmitchell/melondb";
+
+export const melon = createMelon<TableModels, TableData>({
+  // ...schema
+  idGenerator: () => uuidv7(),
+});
+```
+
+On web you can skip `react-native-get-random-values`, because browsers already provide `crypto.getRandomValues`.
+
+---
+
+## License
+
+MIT

package/lib/cleanRow.d.ts

@@ -0,0 +1,11 @@
+export type DirtyRaw = {
+    [key: string]: any;
+};
+/**
+ * Build a mapper that strips WatermelonDB meta fields (`_status`, `_changed`)
+ * from a model's `_raw` and optionally merges extra fields.
+ *
+ * Useful when exporting rows to JSON, PDF, or a remote API.
+ */
+export declare const cleanRow: (changes?: DirtyRaw) => (row?: DirtyRaw) => DirtyRaw | undefined;
+//# sourceMappingURL=cleanRow.d.ts.map

package/lib/cleanRow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanRow.d.ts","sourceRoot":"","sources":["../src/cleanRow.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,QAAQ,GAAG;IAErB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACnB,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,GAAI,UAAS,QAAa,MACrC,MAAM,QAAQ,KAAG,QAAQ,GAAG,SASrC,CAAA"}

package/lib/cleanRow.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.cleanRow = void 0;
+/**
+ * Build a mapper that strips WatermelonDB meta fields (`_status`, `_changed`)
+ * from a model's `_raw` and optionally merges extra fields.
+ *
+ * Useful when exporting rows to JSON, PDF, or a remote API.
+ */
+const cleanRow = (changes = {}) => {
+    return (row) => {
+        if (!row) {
+            return undefined;
+        }
+        const { _status, _changed, ...rest } = row._raw;
+        return { ...rest, ...changes };
+    };
+};
+exports.cleanRow = cleanRow;
+//# sourceMappingURL=cleanRow.js.map

package/lib/cleanRow.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cleanRow.js","sourceRoot":"","sources":["../src/cleanRow.ts"],"names":[],"mappings":";;;AAKA;;;;;GAKG;AACI,MAAM,QAAQ,GAAG,CAAC,UAAoB,EAAE,EAAE,EAAE;IACjD,OAAO,CAAC,GAAc,EAAwB,EAAE;QAC9C,IAAI,CAAC,GAAG,EAAE,CAAC;YACT,OAAO,SAAS,CAAA;QAClB,CAAC;QAED,MAAM,EAAE,OAAO,EAAE,QAAQ,EAAE,GAAG,IAAI,EAAE,GAAG,GAAG,CAAC,IAAI,CAAA;QAE/C,OAAO,EAAE,GAAG,IAAI,EAAE,GAAG,OAAO,EAAE,CAAA;IAChC,CAAC,CAAA;AACH,CAAC,CAAA;AAVY,QAAA,QAAQ,YAUpB"}

package/lib/createAdapter.d.ts

@@ -0,0 +1,5 @@
+import SQLiteAdapter from "@nozbe/watermelondb/adapters/sqlite";
+import { SQLiteAdapterOptions } from "@nozbe/watermelondb/adapters/sqlite/type";
+/** Native (iOS / Android) SQLite adapter. */
+export declare const createAdapter: (options: SQLiteAdapterOptions) => SQLiteAdapter;
+//# sourceMappingURL=createAdapter.d.ts.map

package/lib/createAdapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdapter.d.ts","sourceRoot":"","sources":["../src/createAdapter.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,MAAM,qCAAqC,CAAC;AAChE,OAAO,EAAE,oBAAoB,EAAE,MAAM,0CAA0C,CAAC;AAEhF,6CAA6C;AAC7C,eAAO,MAAM,aAAa,GAAI,SAAS,oBAAoB,kBAE1D,CAAC"}

package/lib/createAdapter.js

@@ -0,0 +1,13 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = void 0;
+const sqlite_1 = __importDefault(require("@nozbe/watermelondb/adapters/sqlite"));
+/** Native (iOS / Android) SQLite adapter. */
+const createAdapter = (options) => {
+    return new sqlite_1.default(options);
+};
+exports.createAdapter = createAdapter;
+//# sourceMappingURL=createAdapter.js.map

package/lib/createAdapter.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdapter.js","sourceRoot":"","sources":["../src/createAdapter.ts"],"names":[],"mappings":";;;;;;AAAA,iFAAgE;AAGhE,6CAA6C;AACtC,MAAM,aAAa,GAAG,CAAC,OAA6B,EAAE,EAAE;IAC7D,OAAO,IAAI,gBAAa,CAAC,OAAO,CAAC,CAAC;AACpC,CAAC,CAAC;AAFW,QAAA,aAAa,iBAExB"}

package/lib/createAdapter.web.d.ts

@@ -0,0 +1,4 @@
+import LokiJSAdapter, { LokiAdapterOptions } from '@nozbe/watermelondb/adapters/lokijs';
+/** Web adapter (LokiJS + IndexedDB). Metro/webpack resolve this via `.web.ts`. */
+export declare const createAdapter: (options: LokiAdapterOptions) => LokiJSAdapter;
+//# sourceMappingURL=createAdapter.web.d.ts.map

package/lib/createAdapter.web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdapter.web.d.ts","sourceRoot":"","sources":["../src/createAdapter.web.ts"],"names":[],"mappings":"AAAA,OAAO,aAAa,EAAE,EACpB,kBAAkB,EACnB,MAAM,qCAAqC,CAAA;AAE5C,kFAAkF;AAClF,eAAO,MAAM,aAAa,GAAI,SAAS,kBAAkB,kBAMxD,CAAA"}

package/lib/createAdapter.web.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createAdapter = void 0;
+const lokijs_1 = __importDefault(require("@nozbe/watermelondb/adapters/lokijs"));
+/** Web adapter (LokiJS + IndexedDB). Metro/webpack resolve this via `.web.ts`. */
+const createAdapter = (options) => {
+    return new lokijs_1.default({
+        useWebWorker: false,
+        useIncrementalIndexedDB: true,
+        ...options,
+    });
+};
+exports.createAdapter = createAdapter;
+//# sourceMappingURL=createAdapter.web.js.map

package/lib/createAdapter.web.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"createAdapter.web.js","sourceRoot":"","sources":["../src/createAdapter.web.ts"],"names":[],"mappings":";;;;;;AAAA,iFAE4C;AAE5C,kFAAkF;AAC3E,MAAM,aAAa,GAAG,CAAC,OAA2B,EAAE,EAAE;IAC3D,OAAO,IAAI,gBAAa,CAAC;QACvB,YAAY,EAAE,KAAK;QACnB,uBAAuB,EAAE,IAAI;QAC7B,GAAG,OAAO;KACX,CAAC,CAAA;AACJ,CAAC,CAAA;AANY,QAAA,aAAa,iBAMzB"}

package/lib/createMelon.d.ts

@@ -0,0 +1,37 @@
+import { ComponentType } from "react";
+import { Collection, Model } from "@nozbe/watermelondb";
+import { WatermelonParams } from "./createWatermelon";
+export type Melon = ReturnType<typeof createMelon>;
+export type MelonParams = WatermelonParams & {
+    /** Console logging for failed lookups and database resets. Defaults to `true`. */
+    logging?: boolean;
+    /** Replaces WatermelonDB's global id generator. Defaults to WatermelonDB's own generator. */
+    idGenerator?: () => string;
+};
+export declare const createMelon: <TableModels extends Record<string, Model>, TableData extends Record<keyof TableModels, unknown>>(params: MelonParams) => {
+    /** Underlying WatermelonDB `Database` instance. */
+    db: import("@nozbe/watermelondb").Database;
+    enhance: <Injected, Query = unknown, Props = unknown>(enhancer: (Component: ComponentType<Injected & Props>) => ComponentType<Query & Props>, Component: ComponentType<Injected & Props>) => ComponentType<Query & Props>;
+    get: <T extends Extract<keyof TableModels, string>>(tableName: T) => Collection<TableModels[T]>;
+    getRowById: <T extends Extract<keyof TableModels, string>>(tableName: T, id: string) => Promise<TableModels[T] | null>;
+    insert: <T extends Extract<keyof TableModels, string>>(tableName: T, data: TableData[T]) => Promise<string>;
+    insertBatch: <T extends Extract<keyof TableModels, string>>(tableName: T, data: TableData[T][]) => Promise<void>;
+    updateRow: <T extends Extract<keyof TableModels, string>>(model: TableModels[T], updater: (row: TableModels[T]) => void) => Promise<TableModels[T]>;
+    updateColumn: <M extends Model, P extends keyof M, V extends M[P]>(model: M, property: P, value: V) => Promise<M>;
+    updateColumns: <M extends Model, P_1 extends keyof M, V_1 extends M[P_1]>(model: M, columns: {
+        property: P_1;
+        value: V_1;
+    }[]) => Promise<M>;
+    deleteRow: <T extends Model>(row: T) => Promise<void>;
+    deleteRowById: <T extends Extract<keyof TableModels, string>>(tableName: T, id: string | undefined) => Promise<void>;
+    deleteBatch: <T extends Model>(rows: T[]) => Promise<void>;
+    deleteTable: <T extends Extract<keyof TableModels, string>>(tableName: T) => Promise<void>;
+    emptyTable: <T extends Extract<keyof TableModels, string>>(tableName: T, batchSize?: number) => Promise<void>;
+    getRowCount: (tableName: Extract<keyof TableModels, string>) => Promise<number>;
+    logRowCount: (tableName: Extract<keyof TableModels, string>) => Promise<void>;
+    logAllRows: (tableName: Extract<keyof TableModels, string>) => Promise<void>;
+    resetDatabase: () => Promise<void>;
+    getDatabaseAvailable: () => boolean;
+    subscribeDatabaseAvailable: (listener: (available: boolean) => void) => () => void;
+};
+//# sourceMappingURL=createMelon.d.ts.map

package/lib/createMelon.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"createMelon.d.ts","sourceRoot":"","sources":["../src/createMelon.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AACtC,OAAO,EAAE,UAAU,EAAE,KAAK,EAAK,MAAM,qBAAqB,CAAC;AAE3D,OAAO,EAAoB,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AAGxE,MAAM,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,WAAW,CAAC,CAAC;AAEnD,MAAM,MAAM,WAAW,GAAG,gBAAgB,GAAG;IAC3C,kFAAkF;IAClF,OAAO,CAAC,EAAE,OAAO,CAAC;IAClB,6FAA6F;IAC7F,WAAW,CAAC,EAAE,MAAM,MAAM,CAAC;CAC5B,CAAC;AAEF,eAAO,MAAM,WAAW,GACtB,WAAW,SAAS,MAAM,CAAC,MAAM,EAAE,KAAK,CAAC,EACzC,SAAS,SAAS,MAAM,CAAC,MAAM,WAAW,EAAE,OAAO,CAAC,EAEpD,QAAQ,WAAW;IAgQjB,mDAAmD;;cA9OpC,QAAQ,EAAE,KAAK,YAAY,KAAK,sBACrC,CACR,SAAS,EAAE,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,KACvC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC,aACtB,aAAa,CAAC,QAAQ,GAAG,KAAK,CAAC,KACzC,aAAa,CAAC,KAAK,GAAG,KAAK,CAAC;UAIlB,CAAC,wDAAgC,CAAC,KACE,UAAU,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC;iBAGjD,CAAC,wDAAgC,CAAC,MAAM,MAAM;aAYlD,CAAC,wDACV,CAAC,QACN,SAAS,CAAC,CAAC,CAAC,KACjB,OAAO,CAAC,MAAM,CAAC;kBAUS,CAAC,wDACf,CAAC,QACN,SAAS,CAAC,CAAC,CAAC,EAAE;gBAaG,CAAC,oDACjB,WAAW,CAAC,CAAC,CAAC,WACZ,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC,CAAC,KAAK,IAAI;mBASlB,CAAC,SAAS,KAAK,EAAE,CAAC,SAAS,MAAM,CAAC,EAAE,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,SAC/D,CAAC,YACE,CAAC,SACJ,CAAC;oBAgBa,CAAC,SAAS,KAAK,cAAY,MAAM,CAAC,cAAY,CAAC,CAAC,GAAC,CAAC,SAChE,CAAC,WACC;QAAE,QAAQ,EAAE,GAAC,CAAC;QAAC,KAAK,EAAE,GAAC,CAAA;KAAE,EAAE;gBAcb,CAAC,SAAS,KAAK,OAAO,CAAC;oBAMnB,CAAC,wDACjB,CAAC,MACR,MAAM,GAAG,SAAS;kBAYG,CAAC,SAAS,KAAK,QAAQ,CAAC,EAAE;kBAe1B,CAAC,wDAAgC,CAAC;iBAkBnC,CAAC,wDACd,CAAC;;;;;;2CA0CF,CAAC,SAAS,EAAE,OAAO,KAAK,IAAI;CAiEzC,CAAC"}