@dockstat/sqlite-wrapper 1.1.0 → 1.1.1

package/LICENSE

@@ -0,0 +1,373 @@
+Mozilla Public License Version 2.0
+==================================
+
+1. Definitions
+--------------
+
+1.1. "Contributor"
+    means each individual or legal entity that creates, contributes to
+    the creation of, or owns Covered Software.
+
+1.2. "Contributor Version"
+    means the combination of the Contributions of others (if any) used
+    by a Contributor and that particular Contributor's Contribution.
+
+1.3. "Contribution"
+    means Covered Software of a particular Contributor.
+
+1.4. "Covered Software"
+    means Source Code Form to which the initial Contributor has attached
+    the notice in Exhibit A, the Executable Form of such Source Code
+    Form, and Modifications of such Source Code Form, in each case
+    including portions thereof.
+
+1.5. "Incompatible With Secondary Licenses"
+    means
+
+    (a) that the initial Contributor has attached the notice described
+        in Exhibit B to the Covered Software; or
+
+    (b) that the Covered Software was made available under the terms of
+        version 1.1 or earlier of the License, but not also under the
+        terms of a Secondary License.
+
+1.6. "Executable Form"
+    means any form of the work other than Source Code Form.
+
+1.7. "Larger Work"
+    means a work that combines Covered Software with other material, in
+    a separate file or files, that is not Covered Software.
+
+1.8. "License"
+    means this document.
+
+1.9. "Licensable"
+    means having the right to grant, to the maximum extent possible,
+    whether at the time of the initial grant or subsequently, any and
+    all of the rights conveyed by this License.
+
+1.10. "Modifications"
+    means any of the following:
+
+    (a) any file in Source Code Form that results from an addition to,
+        deletion from, or modification of the contents of Covered
+        Software; or
+
+    (b) any new file in Source Code Form that contains any Covered
+        Software.
+
+1.11. "Patent Claims" of a Contributor
+    means any patent claim(s), including without limitation, method,
+    process, and apparatus claims, in any patent Licensable by such
+    Contributor that would be infringed, but for the grant of the
+    License, by the making, using, selling, offering for sale, having
+    made, import, or transfer of either its Contributions or its
+    Contributor Version.
+
+1.12. "Secondary License"
+    means either the GNU General Public License, Version 2.0, the GNU
+    Lesser General Public License, Version 2.1, the GNU Affero General
+    Public License, Version 3.0, or any later versions of those
+    licenses.
+
+1.13. "Source Code Form"
+    means the form of the work preferred for making modifications.
+
+1.14. "You" (or "Your")
+    means an individual or a legal entity exercising rights under this
+    License. For legal entities, "You" includes any entity that
+    controls, is controlled by, or is under common control with You. For
+    purposes of this definition, "control" means (a) the power, direct
+    or indirect, to cause the direction or management of such entity,
+    whether by contract or otherwise, or (b) ownership of more than
+    fifty percent (50%) of the outstanding shares or beneficial
+    ownership of such entity.
+
+2. License Grants and Conditions
+--------------------------------
+
+2.1. Grants
+
+Each Contributor hereby grants You a world-wide, royalty-free,
+non-exclusive license:
+
+(a) under intellectual property rights (other than patent or trademark)
+    Licensable by such Contributor to use, reproduce, make available,
+    modify, display, perform, distribute, and otherwise exploit its
+    Contributions, either on an unmodified basis, with Modifications, or
+    as part of a Larger Work; and
+
+(b) under Patent Claims of such Contributor to make, use, sell, offer
+    for sale, have made, import, and otherwise transfer either its
+    Contributions or its Contributor Version.
+
+2.2. Effective Date
+
+The licenses granted in Section 2.1 with respect to any Contribution
+become effective for each Contribution on the date the Contributor first
+distributes such Contribution.
+
+2.3. Limitations on Grant Scope
+
+The licenses granted in this Section 2 are the only rights granted under
+this License. No additional rights or licenses will be implied from the
+distribution or licensing of Covered Software under this License.
+Notwithstanding Section 2.1(b) above, no patent license is granted by a
+Contributor:
+
+(a) for any code that a Contributor has removed from Covered Software;
+    or
+
+(b) for infringements caused by: (i) Your and any other third party's
+    modifications of Covered Software, or (ii) the combination of its
+    Contributions with other software (except as part of its Contributor
+    Version); or
+
+(c) under Patent Claims infringed by Covered Software in the absence of
+    its Contributions.
+
+This License does not grant any rights in the trademarks, service marks,
+or logos of any Contributor (except as may be necessary to comply with
+the notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+No Contributor makes additional grants as a result of Your choice to
+distribute the Covered Software under a subsequent version of this
+License (see Section 10.2) or under the terms of a Secondary License (if
+permitted under the terms of Section 3.3).
+
+2.5. Representation
+
+Each Contributor represents that the Contributor believes its
+Contributions are its original creation(s) or it has sufficient rights
+to grant the rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+This License is not intended to limit any rights You have under
+applicable copyright doctrines of fair use, fair dealing, or other
+equivalents.
+
+2.7. Conditions
+
+Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted
+in Section 2.1.
+
+3. Responsibilities
+-------------------
+
+3.1. Distribution of Source Form
+
+All distribution of Covered Software in Source Code Form, including any
+Modifications that You create or to which You contribute, must be under
+the terms of this License. You must inform recipients that the Source
+Code Form of the Covered Software is governed by the terms of this
+License, and how they can obtain a copy of this License. You may not
+attempt to alter or restrict the recipients' rights in the Source Code
+Form.
+
+3.2. Distribution of Executable Form
+
+If You distribute Covered Software in Executable Form then:
+
+(a) such Covered Software must also be made available in Source Code
+    Form, as described in Section 3.1, and You must inform recipients of
+    the Executable Form how they can obtain a copy of such Source Code
+    Form by reasonable means in a timely manner, at a charge no more
+    than the cost of distribution to the recipient; and
+
+(b) You may distribute such Executable Form under the terms of this
+    License, or sublicense it under different terms, provided that the
+    license for the Executable Form does not attempt to limit or alter
+    the recipients' rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+You may create and distribute a Larger Work under terms of Your choice,
+provided that You also comply with the requirements of this License for
+the Covered Software. If the Larger Work is a combination of Covered
+Software with a work governed by one or more Secondary Licenses, and the
+Covered Software is not Incompatible With Secondary Licenses, this
+License permits You to additionally distribute such Covered Software
+under the terms of such Secondary License(s), so that the recipient of
+the Larger Work may, at their option, further distribute the Covered
+Software under the terms of either this License or such Secondary
+License(s).
+
+3.4. Notices
+
+You may not remove or alter the substance of any license notices
+(including copyright notices, patent notices, disclaimers of warranty,
+or limitations of liability) contained within the Source Code Form of
+the Covered Software, except that You may alter any license notices to
+the extent required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+You may choose to offer, and to charge a fee for, warranty, support,
+indemnity or liability obligations to one or more recipients of Covered
+Software. However, You may do so only on Your own behalf, and not on
+behalf of any Contributor. You must make it absolutely clear that any
+such warranty, support, indemnity, or liability obligation is offered by
+You alone, and You hereby agree to indemnify every Contributor for any
+liability incurred by such Contributor as a result of warranty, support,
+indemnity or liability terms You offer. You may include additional
+disclaimers of warranty and limitations of liability specific to any
+jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+---------------------------------------------------
+
+If it is impossible for You to comply with any of the terms of this
+License with respect to some or all of the Covered Software due to
+statute, judicial order, or regulation then You must: (a) comply with
+the terms of this License to the maximum extent possible; and (b)
+describe the limitations and the code they affect. Such description must
+be placed in a text file included with all distributions of the Covered
+Software under this License. Except to the extent prohibited by statute
+or regulation, such description must be sufficiently detailed for a
+recipient of ordinary skill to be able to understand it.
+
+5. Termination
+--------------
+
+5.1. The rights granted under this License will terminate automatically
+if You fail to comply with any of its terms. However, if You become
+compliant, then the rights granted under this License from a particular
+Contributor are reinstated (a) provisionally, unless and until such
+Contributor explicitly and finally terminates Your grants, and (b) on an
+ongoing basis, if such Contributor fails to notify You of the
+non-compliance by some reasonable means prior to 60 days after You have
+come back into compliance. Moreover, Your grants from a particular
+Contributor are reinstated on an ongoing basis if such Contributor
+notifies You of the non-compliance by some reasonable means, this is the
+first time You have received notice of non-compliance with this License
+from such Contributor, and You become compliant prior to 30 days after
+Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+infringement claim (excluding declaratory judgment actions,
+counter-claims, and cross-claims) alleging that a Contributor Version
+directly or indirectly infringes any patent, then the rights granted to
+You by any and all Contributors for the Covered Software under Section
+2.1 of this License shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all
+end user license agreements (excluding distributors and resellers) which
+have been validly granted by You or Your distributors under this License
+prior to termination shall survive termination.
+
+************************************************************************
+*                                                                      *
+*  6. Disclaimer of Warranty                                           *
+*  -------------------------                                           *
+*                                                                      *
+*  Covered Software is provided under this License on an "as is"       *
+*  basis, without warranty of any kind, either expressed, implied, or  *
+*  statutory, including, without limitation, warranties that the       *
+*  Covered Software is free of defects, merchantable, fit for a        *
+*  particular purpose or non-infringing. The entire risk as to the     *
+*  quality and performance of the Covered Software is with You.        *
+*  Should any Covered Software prove defective in any respect, You     *
+*  (not any Contributor) assume the cost of any necessary servicing,   *
+*  repair, or correction. This disclaimer of warranty constitutes an   *
+*  essential part of this License. No use of any Covered Software is   *
+*  authorized under this License except under this disclaimer.         *
+*                                                                      *
+************************************************************************
+
+************************************************************************
+*                                                                      *
+*  7. Limitation of Liability                                          *
+*  --------------------------                                          *
+*                                                                      *
+*  Under no circumstances and under no legal theory, whether tort      *
+*  (including negligence), contract, or otherwise, shall any           *
+*  Contributor, or anyone who distributes Covered Software as          *
+*  permitted above, be liable to You for any direct, indirect,         *
+*  special, incidental, or consequential damages of any character      *
+*  including, without limitation, damages for lost profits, loss of    *
+*  goodwill, work stoppage, computer failure or malfunction, or any    *
+*  and all other commercial damages or losses, even if such party      *
+*  shall have been informed of the possibility of such damages. This   *
+*  limitation of liability shall not apply to liability for death or   *
+*  personal injury resulting from such party's negligence to the       *
+*  extent applicable law prohibits such limitation. Some               *
+*  jurisdictions do not allow the exclusion or limitation of           *
+*  incidental or consequential damages, so this exclusion and          *
+*  limitation may not apply to You.                                    *
+*                                                                      *
+************************************************************************
+
+8. Litigation
+-------------
+
+Any litigation relating to this License may be brought only in the
+courts of a jurisdiction where the defendant maintains its principal
+place of business and such litigation shall be governed by laws of that
+jurisdiction, without reference to its conflict-of-law provisions.
+Nothing in this Section shall prevent a party's ability to bring
+cross-claims or counter-claims.
+
+9. Miscellaneous
+----------------
+
+This License represents the complete agreement concerning the subject
+matter hereof. If any provision of this License is held to be
+unenforceable, such provision shall be reformed only to the extent
+necessary to make it enforceable. Any law or regulation which provides
+that the language of a contract shall be construed against the drafter
+shall not be used to construe this License against a Contributor.
+
+10. Versions of the License
+---------------------------
+
+10.1. New Versions
+
+Mozilla Foundation is the license steward. Except as provided in Section
+10.3, no one other than the license steward has the right to modify or
+publish new versions of this License. Each version will be given a
+distinguishing version number.
+
+10.2. Effect of New Versions
+
+You may distribute the Covered Software under the terms of the version
+of the License under which You originally received the Covered Software,
+or under the terms of any subsequent version published by the license
+steward.
+
+10.3. Modified Versions
+
+If you create software not governed by this License, and you want to
+create a new license for such software, you may create and use a
+modified version of this License if you rename the license and remove
+any references to the name of the license steward (except to note that
+such modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary
+Licenses
+
+If You choose to distribute Source Code Form that is Incompatible With
+Secondary Licenses under the terms of this version of the License, the
+notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+-------------------------------------------
+
+  This Source Code Form is subject to the terms of the Mozilla Public
+  License, v. 2.0. If a copy of the MPL was not distributed with this
+  file, You can obtain one at https://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular
+file, then You may include the notice in a location (such as a LICENSE
+file in a relevant directory) where a recipient would be likely to look
+for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - "Incompatible With Secondary Licenses" Notice
+---------------------------------------------------------
+
+  This Source Code Form is "Incompatible With Secondary Licenses", as
+  defined by the Mozilla Public License, v. 2.0.

package/README.md

@@ -1,869 +1,53 @@
 # @dockstat/sqlite-wrapper
 
-A comprehensive TypeScript wrapper around Bun's `bun:sqlite` with type-safe table creation, advanced query building, and full SQLite feature support.
+![Bun](https://img.shields.io/badge/Bun-%23000000.svg?style=for-the-badge&logo=bun&logoColor=white)
+![SQLite](https://img.shields.io/badge/sqlite-%2307405e.svg?style=for-the-badge&logo=sqlite&logoColor=white)
+![TypeScript](https://img.shields.io/badge/typescript-%23007ACC.svg?style=for-the-badge&logo=typescript&logoColor=white)
 
-## Features
+**A fast, type-safe TypeScript wrapper for Bun's `bun:sqlite`.**
+Schema-first table helpers, an expressive chainable QueryBuilder, safe defaults (WHERE required for destructive ops), JSON + generated columns, and production-minded pragmas & transactions.
 
-* **Type-safe table creation** with column helpers and comprehensive constraint support
-* **Expressive QueryBuilder** with chainable operations for SELECT, INSERT, UPDATE, DELETE
-* **Advanced WHERE conditions** including regex filtering, raw SQL, operators, and more
-* **Conflict resolution** for INSERT operations (OR IGNORE, OR REPLACE, etc.)
-* **Safety features** requiring WHERE conditions for UPDATE/DELETE operations
-* **Full SQLite support** including JSON columns, generated columns, foreign keys, and more
-* **Performance optimizations** with proper parameter binding and transaction support
+## Install
+> Requires **Bun** runtime
 
----
+```bash
+bun add @dockstat/sqlite-wrapper
+````
 
-## Quick Start
+## 10-second quickstart
 
 ```ts
-import { DB, column, sql } from "@dockstat/sqlite-wrapper";
+import { DB, column } from "@dockstat/sqlite-wrapper";
 
-interface User {
-  id?: number;
-  name: string;
-  email: string;
-  type: string;
-  active?: boolean;
-  metadata?: object;
-  created_at?: number;
-  updated_at?: number;
-}
+const db = new DB("app.db", { pragmas: [["journal_mode","WAL"], ["foreign_keys","ON"]] });
 
-// Create database with optimized settings
-const db = new DB("app.db", {
-  pragmas: [
-    ["journal_mode", "WAL"],
-    ["synchronous", "NORMAL"],
-    ["foreign_keys", "ON"],
-    ["cache_size", -64000]
-  ]
-});
-
-// Create table with type-safe column definitions
 db.createTable("users", {
-  id: column.id(), // INTEGER PRIMARY KEY AUTOINCREMENT
+  id: column.id(),
   name: column.text({ notNull: true }),
   email: column.text({ unique: true, notNull: true }),
-  type: column.enum(["admin", "user", "guest"], { default: "user" }),
-  active: column.boolean({ default: true }),
-  metadata: column.json({ validateJson: true }),
-  created_at: column.createdAt(), // Auto-timestamp
-  updated_at: column.updatedAt()
+  created_at: column.createdAt()
 });
 
-// Query with the powerful QueryBuilder
-const users = db.table<User>("users")
-  .select(["id", "name", "email"])
+const users = db.table("users")
+  .select(["id","name","email"])
   .where({ active: true })
-  .whereRgx({ email: /@company\.com$/i })
-  .orderBy("created_at")
-  .desc()
+  .orderBy("created_at").desc()
   .limit(10)
   .all();
-
-console.log(users);
-```
-
----
-
-## Table Creation
-
-### Modern Column Helpers (Recommended)
-
-Create tables with type-safe column definitions and comprehensive SQLite feature support:
-
-```ts
-import { DB, column, sql } from "@dockstat/sqlite-wrapper";
-
-db.createTable("products", {
-  // Primary keys and auto-increment
-  id: column.id(), // INTEGER PRIMARY KEY AUTOINCREMENT
-  uuid: column.uuid({ generateDefault: true }),
-  
-  // Text columns with constraints
-  name: column.text({ notNull: true }),
-  description: column.text({ length: 1000 }),
-  sku: column.varchar(50, { unique: true }),
-  
-  // Numeric columns
-  price: column.numeric({ precision: 10, scale: 2, check: "price > 0" }),
-  quantity: column.integer({ default: 0, check: "quantity >= 0" }),
-  weight: column.real(),
-  
-  // Boolean with validation
-  active: column.boolean({ default: true }),
-  
-  // Enums with validation
-  category: column.enum(["electronics", "clothing", "books"], {
-    default: "electronics"
-  }),
-  
-  // JSON data
-  specifications: column.json({ validateJson: true }),
-  tags: column.json(),
-  
-  // Dates and timestamps
-  manufactured_date: column.date(),
-  created_at: column.createdAt(), // Auto-managed
-  updated_at: column.updatedAt(),
-  
-  // Foreign keys
-  supplier_id: column.foreignKey("suppliers", "id", {
-    onDelete: "SET NULL",
-    onUpdate: "CASCADE"
-  }),
-  
-  // Generated columns
-  display_price: {
-    type: "TEXT",
-    generated: {
-      expression: "printf('$%.2f', price)",
-      stored: false // VIRTUAL column
-    }
-  }
-}, {
-  constraints: {
-    // Table-level constraints
-    unique: [["sku", "supplier_id"]], // Composite unique
-    check: ["price > 0 OR category = 'free'"],
-    foreignKeys: [{
-      columns: ["supplier_id"],
-      references: {
-        table: "suppliers",
-        columns: ["id"],
-        onDelete: "CASCADE"
-      }
-    }]
-  },
-  comment: "Product catalog with full specifications"
-});
-```
-
-### Available Column Types
-
-```ts
-// Integer types
-column.integer()
-column.integer({ size: "BIGINT" })
-column.id() // INTEGER PRIMARY KEY AUTOINCREMENT
-
-// Text types
-column.text()
-column.varchar(255)
-column.char(10)
-column.uuid()
-
-// Numeric types
-column.real()
-column.numeric({ precision: 10, scale: 2 })
-column.numeric({ variant: "DECIMAL" })
-
-// Date/Time types
-column.date()
-column.time()
-column.datetime()
-column.timestamp()
-column.createdAt() // Auto-managed creation timestamp
-column.updatedAt() // Auto-managed update timestamp
-
-// Special types
-column.boolean() // INTEGER with CHECK constraint
-column.json() // TEXT with optional validation
-column.blob()
-column.enum(["value1", "value2"])
-
-// Foreign keys
-column.foreignKey("other_table", "other_column", {
-  onDelete: "CASCADE",
-  onUpdate: "RESTRICT"
-})
-```
-
-### Column Constraints
-
-All column helpers support comprehensive constraints:
-
-```ts
-column.text({
-  notNull: true,
-  unique: true,
-  default: "default_value",
-  check: "length(column_name) > 0",
-  collate: "NOCASE",
-  comment: "User description"
-})
-
-// Default value expressions
-column.timestamp({
-  default: sql.currentTimestamp()
-})
-
-column.text({
-  default: sql.raw("upper(hex(randomblob(16)))")
-})
-```
-
-### Legacy Table Creation
-
-Object-style (still supported):
-
-```ts
-db.createTable("posts", {
-  id: "INTEGER PRIMARY KEY AUTOINCREMENT",
-  title: "TEXT NOT NULL",
-  body: "TEXT",
-  author_id: "INTEGER NOT NULL",
-  published: "INTEGER NOT NULL DEFAULT 0"
-}, { ifNotExists: true });
-```
-
-String-style (still supported):
-
-```ts
-db.createTable("events", `
-  id INTEGER PRIMARY KEY,
-  name TEXT NOT NULL,
-  occurred_at INTEGER NOT NULL
-`);
-```
-
----
-
-## Query Building
-
-### SELECT Operations
-
-```ts
-// Basic selection
-const users = db.table<User>("users")
-  .select(["id", "name", "email"])
-  .where({ active: true })
-  .all();
-
-// Complex conditions
-const results = db.table<User>("users")
-  .where({ type: "admin" })
-  .whereIn("id", [1, 2, 3, 4, 5])
-  .whereOp("created_at", ">", Date.now() - 86400000)
-  .whereRaw("name LIKE ?", ["%admin%"])
-  .whereRgx({ email: /@company\.com$/i }) // Client-side regex
-  .orderBy("created_at")
-  .desc()
-  .limit(50)
-  .offset(100)
-  .all();
-
-// Result methods
-const allUsers = db.table<User>("users").all();
-const firstUser = db.table<User>("users").first();
-const singleUser = db.table<User>("users").where({ id: 1 }).get();
-const userCount = db.table<User>("users").where({ active: true }).count();
-const userExists = db.table<User>("users").where({ email: "test@example.com" }).exists();
-
-// Single values
-const userName = db.table<User>("users").where({ id: 1 }).value("name");
-const allNames = db.table<User>("users").pluck("name");
-```
-
-### INSERT Operations
-
-```ts
-// Single insert
-const result = db.table<User>("users").insert({
-  name: "John Doe",
-  email: "john@example.com",
-  type: "user"
-});
-console.log(`Inserted user with ID: ${result.insertId}`);
-
-// Bulk insert
-const users = [
-  { name: "Alice", email: "alice@example.com" },
-  { name: "Bob", email: "bob@example.com" }
-];
-const bulkResult = db.table<User>("users").insert(users);
-
-// Conflict resolution
-db.table<User>("users").insertOrIgnore(userData);
-db.table<User>("users").insertOrReplace(userData);
-
-// Custom conflict resolution
-db.table<User>("users").insert(userData, {
-  orIgnore: true,
-  orReplace: false,
-  orAbort: false,
-  orFail: false,
-  orRollback: false
-});
-
-// Insert and get back the row
-const newUser = db.table<User>("users").insertAndGet({
-  name: "Jane",
-  email: "jane@example.com"
-});
-
-// Batch insert with transaction
-db.table<User>("users").insertBatch(largeUserArray);
-```
-
-### UPDATE Operations
-
-All UPDATE operations require WHERE conditions for safety:
-
-```ts
-// Basic update
-const result = db.table<User>("users")
-  .where({ id: 1 })
-  .update({ name: "Updated Name" });
-
-// Complex conditions
-db.table<User>("users")
-  .where({ type: "user" })
-  .whereRgx({ email: /@oldcompany\.com$/i })
-  .update({ type: "migrated_user" });
-
-// Increment/decrement
-db.table<User>("users")
-  .where({ id: 1 })
-  .increment("login_count", 1);
-
-// Upsert (insert or update)
-db.table<User>("users").upsert({
-  id: 1,
-  name: "John",
-  email: "john@example.com"
-});
-
-// Update and get affected rows
-const updatedUsers = db.table<User>("users")
-  .where({ active: false })
-  .updateAndGet({ active: true });
-
-// Batch update
-db.table<User>("users").updateBatch([
-  { where: { id: 1 }, data: { name: "User 1" } },
-  { where: { id: 2 }, data: { name: "User 2" } }
-]);
-```
-
-### DELETE Operations
-
-All DELETE operations require WHERE conditions for safety:
-
-```ts
-// Basic delete
-const result = db.table<User>("users")
-  .where({ active: false })
-  .delete();
-
-// Complex conditions
-db.table<User>("users")
-  .where({ type: "temporary" })
-  .whereOp("created_at", "<", Date.now() - 604800000)
-  .delete();
-
-// Delete and get deleted rows
-const deletedUsers = db.table<User>("users")
-  .where({ active: false })
-  .deleteAndGet();
-
-// Soft delete
-db.table<User>("users")
-  .where({ id: 1 })
-  .softDelete("deleted_at", Date.now());
-
-// Restore soft deleted
-db.table<User>("users")
-  .where({ id: 1 })
-  .restore("deleted_at");
-
-// Utility methods
-db.table<User>("users").deleteOlderThan("created_at", Date.now() - 2592000000);
-db.table<User>("users").deleteDuplicates(["email"]);
-db.table<User>("users").truncate(); // Delete all rows
-
-// Batch delete
-db.table<User>("users").deleteBatch([
-  { type: "temp" },
-  { active: false }
-]);
-```
-
----
-
-## Advanced Features
-
-### JSON Column Support
-
-```ts
-interface UserWithMetadata {
-  id: number;
-  name: string;
-  metadata: {
-    preferences: object;
-    settings: object;
-  };
-}
-
-// Configure JSON columns for automatic serialization/deserialization
-const users = db.table<UserWithMetadata>("users", {
-  jsonColumns: ["metadata"]
-});
-
-// Insert with automatic JSON serialization
-users.insert({
-  name: "John",
-  metadata: {
-    preferences: { theme: "dark" },
-    settings: { notifications: true }
-  }
-});
-
-// Query returns properly deserialized objects
-const user = users.where({ id: 1 }).first();
-console.log(user.metadata.preferences.theme); // "dark"
-```
-
-### Regex Filtering
-
-```ts
-// Client-side regex filtering
-const gmailUsers = db.table<User>("users")
-  .where({ active: true }) // SQL filter first
-  .whereRgx({ email: /@gmail\.com$/i }) // Then regex filter
-  .all();
-
-// Multiple regex conditions
-const results = db.table<User>("users")
-  .whereRgx({
-    email: /@(gmail|yahoo)\.com$/i,
-    name: /^[A-Z]/
-  })
-  .all();
-```
-
-### Raw SQL and Advanced Conditions
-
-```ts
-// Raw WHERE expressions
-db.table<User>("users")
-  .whereRaw("created_at > ? AND (type = ? OR type = ?)", [
-    Date.now() - 86400000,
-    "admin",
-    "moderator"
-  ])
-  .all();
-
-// Operator helpers
-db.table<User>("users")
-  .whereOp("created_at", ">=", startDate)
-  .whereOp("created_at", "<=", endDate)
-  .whereOp("name", "LIKE", "%john%")
-  .all();
-
-// BETWEEN clauses
-db.table<User>("users")
-  .whereBetween("created_at", startDate, endDate)
-  .whereNotBetween("age", 0, 18)
-  .all();
-
-// NULL checks
-db.table<User>("users")
-  .whereNull("deleted_at")
-  .whereNotNull("email")
-  .all();
-
-// IN clauses
-db.table<User>("users")
-  .whereIn("type", ["admin", "moderator"])
-  .whereNotIn("status", ["banned", "suspended"])
-  .all();
 ```
 
-### Database Configuration
+## Why use it?
 
-```ts
-// Constructor options
-const db = new DB("app.db", {
-  pragmas: [
-    ["journal_mode", "WAL"],
-    ["synchronous", "NORMAL"],
-    ["foreign_keys", "ON"],
-    ["cache_size", -64000],
-    ["temp_store", "memory"]
-  ],
-  loadExtensions: [
-    "/path/to/regexp_extension.so"
-  ]
-});
+* ⚡ Bun-native, high-performance bindings
+* 🔒 Type-safe table & query APIs (compile-time checks)
+* 🧭 Full SQLite feature support: JSON, generated columns, foreign keys, indexes
+* 🛡️ Safety-first defaults — prevents accidental full-table updates/deletes
+* 🚀 Designed for production workflows: WAL, pragmatic PRAGMAs, bulk ops, transactions
 
-// Runtime PRAGMA management
-db.pragma("cache_size", -32000);
-const journalMode = db.pragma("journal_mode");
+## Docs & examples
 
-// Extension loading
-db.loadExtension("/path/to/custom_extension.so");
-
-// Database info
-const tableInfo = db.getTableInfo("users");
-const foreignKeys = db.getForeignKeys("users");
-const indexes = db.getIndexes("users");
-```
-
----
-
-## Performance Considerations
-
-### Query Optimization
-
-1. **Use SQL filters before regex**: Always use `.where()` conditions to reduce the dataset before applying `.whereRgx()` filters.
-
-```ts
-// Good: SQL filter first, then regex
-db.table<User>("users")
-  .where({ active: true, type: "user" }) // Reduces dataset
-  .whereRgx({ email: /@company\.com$/i }) // Then regex filter
-  .all();
+See full technical docs in `docs/technical.md` and `examples/` for e-commerce, migrations, and transactions.
 
-// Avoid: Regex on entire table
-db.table<User>("users")
-  .whereRgx({ email: /@company\.com$/i })
-  .all();
-```
-
-2. **Use appropriate indexes**: Create indexes on frequently queried columns.
-
-```ts
-db.createIndex("idx_users_email", "users", "email", { unique: true });
-db.createIndex("idx_users_created_at", "users", "created_at");
-db.createIndex("idx_users_type_active", "users", ["type", "active"]);
-```
-
-3. **Batch operations**: Use bulk operations for better performance.
-
-```ts
-// Good: Bulk insert
-db.table<User>("users").insertBatch(largeArray);
-
-// Avoid: Individual inserts
-largeArray.forEach(user => db.table<User>("users").insert(user));
-```
-
-### Transaction Management
-
-```ts
-// Manual transactions
-db.begin();
-try {
-  db.table<User>("users").insert(userData1);
-  db.table<User>("users").insert(userData2);
-  db.commit();
-} catch (error) {
-  db.rollback();
-  throw error;
-}
-
-// Automatic transaction wrapper
-const result = db.transaction(() => {
-  const user = db.table<User>("users").insert(userData);
-  db.table("audit_log").insert({ action: "user_created", user_id: user.insertId });
-  return user;
-});
-```
-
-### Memory and Performance Tips
-
-- Use `PRAGMA cache_size` to tune memory usage
-- Enable WAL mode for better concurrency
-- Use `PRAGMA optimize` periodically for query optimization
-- Consider `WITHOUT ROWID` tables for specific use cases
-- Use `PRAGMA vacuum` to reclaim space after large deletions
-
----
-
-## Error Handling and Safety
-
-### Required WHERE Conditions
-
-UPDATE and DELETE operations require WHERE conditions to prevent accidental data modification:
-
-```ts
-// This will throw an error
-try {
-  db.table<User>("users").update({ active: false });
-} catch (error) {
-  console.error("UPDATE requires WHERE conditions");
-}
-
-// This is safe
-db.table<User>("users")
-  .where({ type: "temporary" })
-  .update({ active: false });
-```
-
-### Type Safety
-
-The library provides comprehensive TypeScript support:
-
-```ts
-interface StrictUser {
-  id: number;
-  name: string;
-  email: string;
-}
-
-const users = db.table<StrictUser>("users");
-
-// TypeScript will enforce correct column names
-users.select(["id", "name"]); // ✓ Valid
-users.select(["invalid_column"]); // ✗ TypeScript error
-
-// TypeScript will enforce correct data types
-users.insert({ name: "John", email: "john@example.com" }); // ✓ Valid
-users.insert({ name: 123 }); // ✗ TypeScript error
-```
-
-### Parameter Binding
-
-All queries use proper parameter binding to prevent SQL injection:
-
-```ts
-// Safe - uses parameter binding
-db.table<User>("users")
-  .whereRaw("name = ? AND email = ?", [userName, userEmail])
-  .all();
-
-// Parameters are automatically escaped
-db.table<User>("users")
-  .where({ name: "O'Reilly" }) // Automatically handled
-  .all();
-```
-
----
-
-## API Reference
-
-### DB Class
-
-```ts
-constructor(path: string, options?: {
-  pragmas?: Array<[string, any]>;
-  loadExtensions?: string[];
-})
-
-// Table operations
-table<T>(tableName: string, jsonConfig?: JsonColumnConfig<T>): QueryBuilder<T>
-createTable(tableName: string, columns: CreateTableColumns, options?: TableOptions): void
-dropTable(tableName: string, options?: { ifExists?: boolean }): void
-
-// Index operations
-createIndex(name: string, table: string, columns: string | string[], options?: IndexOptions): void
-dropIndex(name: string, options?: { ifExists?: boolean }): void
-
-// Database operations
-pragma(name: string, value?: any): any
-loadExtension(path: string): void
-exec(sql: string): void
-prepare(sql: string): Statement
-transaction<T>(fn: () => T): T
-begin(): void
-commit(): void
-rollback(): void
-close(): void
-
-// Introspection
-getTableInfo(tableName: string): TableInfo[]
-getForeignKeys(tableName: string): ForeignKeyInfo[]
-getIndexes(tableName: string): IndexInfo[]
-getSchema(): SchemaInfo[]
-```
-
-### QueryBuilder Class
-
-```ts
-// WHERE conditions
-where(conditions: WhereCondition<T>): this
-whereRgx(conditions: RegexCondition<T>): this
-whereRaw(expr: string, params?: any[]): this
-whereExpr(expr: string, params?: any[]): this
-whereIn(column: keyof T, values: any[]): this
-whereNotIn(column: keyof T, values: any[]): this
-whereOp(column: keyof T, op: string, value: any): this
-whereBetween(column: keyof T, min: any, max: any): this
-whereNotBetween(column: keyof T, min: any, max: any): this
-whereNull(column: keyof T): this
-whereNotNull(column: keyof T): this
-
-// SELECT operations
-select(columns: ColumnNames<T>): this
-orderBy(column: keyof T): this
-asc(): this
-desc(): this
-limit(amount: number): this
-offset(start: number): this
-
-// Result execution
-all(): T[]
-get(): T | null
-first(): T | null
-count(): number
-exists(): boolean
-value<K extends keyof T>(column: K): T[K] | null
-pluck<K extends keyof T>(column: K): T[K][]
-
-// INSERT operations
-insert(data: Partial<T> | Partial<T>[], options?: InsertOptions): InsertResult
-insertOrIgnore(data: Partial<T> | Partial<T>[]): InsertResult
-insertOrReplace(data: Partial<T> | Partial<T>[]): InsertResult
-insertAndGet(data: Partial<T>, options?: InsertOptions): T | null
-insertBatch(rows: Partial<T>[], options?: InsertOptions): InsertResult
-
-// UPDATE operations
-update(data: Partial<T>): UpdateResult
-upsert(data: Partial<T>): UpdateResult
-increment(column: keyof T, amount?: number): UpdateResult
-decrement(column: keyof T, amount?: number): UpdateResult
-updateAndGet(data: Partial<T>): T[]
-updateBatch(updates: Array<{ where: Partial<T>; data: Partial<T> }>): UpdateResult
-
-// DELETE operations
-delete(): DeleteResult
-deleteAndGet(): T[]
-softDelete(deletedColumn?: keyof T, deletedValue?: any): DeleteResult
-restore(deletedColumn?: keyof T): DeleteResult
-deleteBatch(conditions: Array<Partial<T>>): DeleteResult
-truncate(): DeleteResult
-deleteOlderThan(timestampColumn: keyof T, olderThan: number): DeleteResult
-deleteDuplicates(columns: Array<keyof T>): DeleteResult
-```
-
-### Result Types
-
-```ts
-interface InsertResult {
-  insertId: number;
-  changes: number;
-}
-
-interface UpdateResult {
-  changes: number;
-}
-
-interface DeleteResult {
-  changes: number;
-}
-
-interface InsertOptions {
-  orIgnore?: boolean;
-  orReplace?: boolean;
-  orAbort?: boolean;
-  orFail?: boolean;
-  orRollback?: boolean;
-}
-```
-
----
-
-## Examples
-
-### E-commerce Product Catalog
-
-```ts
-import { DB, column, sql } from "@dockstat/sqlite-wrapper";
-
-interface Product {
-  id?: number;
-  name: string;
-  sku: string;
-  price: number;
-  category: string;
-  specifications?: object;
-  active?: boolean;
-  created_at?: number;
-  updated_at?: number;
-}
-
-const db = new DB("ecommerce.db");
-
-// Create products table
-db.createTable("products", {
-  id: column.id(),
-  name: column.text({ notNull: true }),
-  sku: column.varchar(50, { unique: true, notNull: true }),
-  price: column.numeric({ precision: 10, scale: 2, check: "price > 0" }),
-  category: column.enum(["electronics", "clothing", "books"], {
-    default: "electronics"
-  }),
-  specifications: column.json({ validateJson: true }),
-  active: column.boolean({ default: true }),
-  created_at: column.createdAt(),
-  updated_at: column.updatedAt()
-});
-
-// Query products
-const activeProducts = db.table<Product>("products")
-  .where({ active: true })
-  .whereOp("price", "<=", 100)
-  .orderBy("created_at")
-  .desc()
-  .all();
-
-// Update pricing
-db.table<Product>("products")
-  .where({ category: "electronics" })
-  .whereOp("price", ">", 1000)
-  .increment("price", -50); // $50 discount
-```
-
-### User Management System
-
-```ts
-interface User {
-  id?: number;
-  username: string;
-  email: string;
-  role: string;
-  profile?: object;
-  active?: boolean;
-  last_login?: number;
-  created_at?: number;
-}
-
-// Create users with comprehensive constraints
-db.createTable("users", {
-  id: column.id(),
-  username: column.varchar(50, { 
-    unique: true, 
-    notNull: true,
-    check: "length(username) >= 3"
-  }),
-  email: column.text({ 
-    unique: true, 
-    notNull: true,
-    check: "email LIKE '%@%.%'"
-  }),
-  role: column.enum(["admin", "moderator", "user"], { default: "user" }),
-  profile: column.json(),
-  active: column.boolean({ default: true }),
-  last_login: column.timestamp(),
-  created_at: column.createdAt()
-}, {
-  constraints: {
-    unique: [["username", "email"]]
-  }
-});
-
-// Find inactive users
-const inactiveUsers = db.table<User>("users")
-  .where({ active: true })
-  .whereOp("last_login", "<", Date.now() - 2592000000) // 30 days
-  .all();
-
-// Bulk role assignment
-db.table<User>("users")
-  .whereIn("id", [1, 2, 3, 4, 5])
-  .update({ role: "moderator" });
-```
+## License
 
-This comprehensive wrapper provides everything you need for robust SQLite operations in TypeScript applications with type safety, performance optimizations, and modern development practices.
+MIT — maintained by Dockstat. Contributions welcome.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dockstat/sqlite-wrapper",
-  "version": "1.1.0",
+  "version": "1.1.1",
   "description": "A TypeScript wrapper around bun:sqlite with type-safe query building",
   "type": "module",
   "main": "./dist/index.js",
@@ -35,16 +35,16 @@
     "orm"
   ],
   "author": "Its4Nik",
-  "license": "MIT",
+  "license": "MPL-2.0",
   "repository": {
     "type": "git",
-    "url": "https://github.com/Its4Nik/DockStat",
+    "url": "https://github.com/Its4Nik/DockStat/packages/sqlite-wrapper",
     "directory": "packages/sqlite-wrapper"
   },
   "bugs": {
     "url": "https://github.com/Its4Nik/DockStat/issues"
   },
-  "homepage": "https://github.com/Its4Nik/DockStat/tree/main/packages/sqlite-wrapper",
+  "homepage": "https://outline.itsnik.de/s/9d88c471-373e-4ef2-a955-b1058eb7dc99/doc/dockstatsqlite-wrapper-Lxt4IphXI5",
   "engines": {
     "bun": ">=1.0.0"
   },