meadow-connection-sqlite 1.0.12 → 1.0.14

package/docs/api.md

@@ -1,254 +1,15 @@
 # API Reference
 
-## Class: MeadowConnectionSQLite
-
-Extends `fable-serviceproviderbase`. Manages a connection to a SQLite database file through the better-sqlite3 library.
-
-### Constructor
-
-```javascript
-new MeadowConnectionSQLite(pFable, pManifest, pServiceHash)
-```
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `pFable` | object | A Fable instance |
-| `pManifest` | object | Service manifest / options (optional) |
-| `pServiceHash` | string | Service identifier |
-
-On construction:
-
-- Sets `serviceType` to `'MeadowConnectionSQLite'`
-- Sets `connected` to `false`
-- Reads `SQLiteFilePath` from `fable.settings.SQLite` if available
-
-The provider is not yet connected after construction — call `connectAsync()` to open the database.
-
----
-
-## Properties
-
-### connected
-
-Whether the database connection is open.
-
-**Type:** `boolean`
-
-### db
-
-The raw `better-sqlite3` `Database` instance. Use this for all query operations. Returns `false` before `connectAsync()` is called.
-
-**Type:** `Database | false`
-
-```javascript
-let tmpDB = _Fable.MeadowSQLiteProvider.db;
-
-// Synchronous query methods from better-sqlite3:
-tmpDB.prepare(sql).run(params);    // INSERT, UPDATE, DELETE
-tmpDB.prepare(sql).get(params);    // SELECT single row
-tmpDB.prepare(sql).all(params);    // SELECT all rows
-tmpDB.exec(sql);                   // Execute raw SQL (multi-statement)
-tmpDB.transaction(fn);             // Wrap a function in a transaction
-tmpDB.pragma(string);              // Run a PRAGMA command
-tmpDB.close();                     // Close the database
-```
-
-### SQLite
-
-Reference to the `better-sqlite3` module constructor. Useful for accessing type constants or creating additional database instances.
-
-**Type:** `function`
-
-```javascript
-let tmpSQLiteConstructor = _Fable.MeadowSQLiteProvider.SQLite;
-```
-
-### serviceType
-
-Always `'MeadowConnectionSQLite'`.
-
-**Type:** `string`
-
----
-
-## Methods
-
-### connectAsync(fCallback)
-
-Open a connection to the SQLite database file specified in configuration.
-
-| Parameter | Type | Description |
-|-----------|------|-------------|
-| `fCallback` | function | Callback: `(error, database)` |
-
-**Behavior:**
-
-- If `SQLiteFilePath` is not configured, calls back with an error
-- If already connected, calls back immediately with the existing database (idempotent)
-- Creates the database file if it does not exist
-- Enables WAL (Write-Ahead Logging) journal mode for performance
-- Sets `this.connected = true` on success
-
-```javascript
-_Fable.MeadowSQLiteProvider.connectAsync(
-	(pError, pDatabase) =>
-	{
-		if (pError)
-		{
-			_Fable.log.error(`Connection failed: ${pError}`);
-			return;
-		}
-
-		// pDatabase is the same as _Fable.MeadowSQLiteProvider.db
-		pDatabase.exec('CREATE TABLE IF NOT EXISTS Test (id INTEGER PRIMARY KEY)');
-	});
-```
-
-### connect()
-
-Synchronous wrapper that calls `connectAsync()` without a callback. Logs a warning about potential race conditions. Prefer `connectAsync()`.
-
----
-
-## Configuration
-
-### Fable Settings
-
-```json
-{
-	"SQLite":
-	{
-		"SQLiteFilePath": "./data/myapp.db"
-	}
-}
-```
-
-| Setting | Type | Required | Description |
-|---------|------|----------|-------------|
-| `SQLiteFilePath` | string | Yes | File path or `:memory:` for in-memory databases |
-
-Additional properties are passed through to the `better-sqlite3` constructor:
-
-| Option | Type | Default | Description |
-|--------|------|---------|-------------|
-| `readonly` | boolean | `false` | Open the database in read-only mode |
-| `fileMustExist` | boolean | `false` | Error if the file does not exist |
-| `timeout` | number | `5000` | Milliseconds to wait when the database is locked |
-
----
-
-## Service Registration
-
-The provider integrates with Fable's service manager:
-
-```javascript
-const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
-
-// Register the service type
-_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
-
-// Instantiate (optionally with per-instance options)
-_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider',
-	{
-		SQLiteFilePath: './data/alternate.db',
-		readonly: true
-	});
-
-// Access the provider
-_Fable.MeadowSQLiteProvider.connectAsync((pError) => { /* ... */ });
-```
-
-Constructor options override Fable settings, allowing multiple providers with different configurations.
-
----
-
-## better-sqlite3 Query API
-
-After connecting, all queries go through the `db` getter. Here is a quick reference for the better-sqlite3 methods you will use most:
-
-### Execute Raw SQL
-
-```javascript
-tmpDB.exec(`
-	CREATE TABLE IF NOT EXISTS Book (
-		IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
-		Title TEXT DEFAULT ''
-	);
-	CREATE INDEX IF NOT EXISTS idx_book_title ON Book(Title);
-`);
-```
-
-`exec()` runs one or more SQL statements. It does not return data.
-
-### Prepared Statements
-
-```javascript
-let tmpStmt = tmpDB.prepare('SELECT * FROM Book WHERE Author = ?');
-
-// Single row
-let tmpRow = tmpStmt.get('Frank Herbert');
-
-// All rows
-let tmpRows = tmpStmt.all('Frank Herbert');
-
-// Modification
-let tmpInsert = tmpDB.prepare('INSERT INTO Book (Title, Author) VALUES (?, ?)');
-let tmpInfo = tmpInsert.run('Dune', 'Frank Herbert');
-// tmpInfo.changes = 1, tmpInfo.lastInsertRowid = 1
-```
-
-### Named Parameters
-
-```javascript
-let tmpStmt = tmpDB.prepare('SELECT * FROM Book WHERE Author = @author AND YearPublished > @year');
-let tmpRows = tmpStmt.all({ author: 'Isaac Asimov', year: 1950 });
-```
-
-### Transactions
-
-```javascript
-let tmpBulkInsert = tmpDB.transaction(
-	(pBooks) =>
-	{
-		let tmpStmt = tmpDB.prepare('INSERT INTO Book (Title, Author) VALUES (?, ?)');
-		for (let tmpBook of pBooks)
-		{
-			tmpStmt.run(tmpBook.Title, tmpBook.Author);
-		}
-	});
-
-// The entire array is inserted atomically
-tmpBulkInsert([
-	{ Title: 'Foundation', Author: 'Isaac Asimov' },
-	{ Title: 'Snow Crash', Author: 'Neal Stephenson' }
-]);
-```
-
-If any statement inside the transaction throws, the entire transaction is rolled back automatically.
-
-### Close
-
-```javascript
-tmpDB.close();
-```
-
----
-
-## Logging
-
-The provider logs connection events through the Fable logging system:
-
-| Event | Level | Message |
-|-------|-------|---------|
-| Connecting | `info` | `Meadow-Connection-SQLite connecting to file [path].` |
-| Connected | `info` | `Meadow-Connection-SQLite successfully connected to SQLite file [path].` |
-| Already connected | `error` | `...is already connected - skipping the second connect call.` |
-| Missing path | `error` | `...database file path is invalid; SQLiteFilePath must be in either...` |
-| Connection error | `error` | `...error connecting to SQLite file [path]: [error]` |
-| No callback | `error` | `...connect() called without a callback...` |
-
----
-
-## Known Limitations
-
-- **No async queries** — better-sqlite3 is synchronous by design. For CPU-bound workloads, consider running queries in a worker thread.
+The full API reference has moved to the [API Reference](api/reference.md) page.
+
+## Individual Function Documentation
+
+- [connectAsync](api/connectAsync.md) -- Open the database and enable WAL (recommended)
+- [connect](api/connect.md) -- Synchronous convenience wrapper
+- [db](api/db.md) -- Access the better-sqlite3 Database instance
+- [SQLite](api/SQLite.md) -- Access the better-sqlite3 module constructor
+- [preparedStatement](api/preparedStatement.md) -- Database handle getter with connection guard
+- [generateCreateTableStatement](api/generateCreateTableStatement.md) -- Generate CREATE TABLE DDL
+- [createTable](api/createTable.md) -- Generate and execute CREATE TABLE
+- [createTables](api/createTables.md) -- Create multiple tables from a schema
+- [generateDropTableStatement](api/generateDropTableStatement.md) -- Generate DROP TABLE DDL

package/docs/architecture.md

@@ -0,0 +1,250 @@
+# Architecture & Design
+
+Meadow Connection SQLite connects Fable applications to SQLite databases through the service provider pattern. This page illustrates the system architecture, connection lifecycle, query model, and how the provider fits into the Meadow ecosystem.
+
+---
+
+## System Architecture
+
+```mermaid
+graph TB
+	App["Fable Application"]
+	Settings["fable.settings.SQLite"]
+	Provider["MeadowConnectionSQLite<br/>(Fable Service Provider)"]
+	BetterSQLite["better-sqlite3<br/>(Native C++ Bindings)"]
+	File["SQLite Database File<br/>or :memory:"]
+
+	App -->|"reads config"| Settings
+	App -->|"connectAsync()"| Provider
+	Provider -->|"new Database(path)"| BetterSQLite
+	BetterSQLite -->|"reads/writes"| File
+	Provider -->|".db getter"| BetterSQLite
+	Settings -->|"SQLiteFilePath"| Provider
+```
+
+---
+
+## Connection Lifecycle
+
+```mermaid
+sequenceDiagram
+	participant App as Application
+	participant SM as ServiceManager
+	participant Provider as MeadowConnectionSQLite
+	participant BS3 as better-sqlite3
+	participant File as Database File
+
+	App->>SM: addServiceType('MeadowSQLiteProvider', lib)
+	App->>SM: instantiateServiceProvider('MeadowSQLiteProvider')
+	SM->>Provider: new MeadowConnectionSQLite(fable, manifest, hash)
+	Note over Provider: connected = false
+
+	App->>Provider: connectAsync(callback)
+
+	alt SQLiteFilePath missing
+		Provider-->>App: callback(error)
+	else Already connected
+		Provider-->>App: callback(null, existingDB)
+	else Normal connect
+		Provider->>BS3: new Database(filePath, options)
+		BS3->>File: Open or create file
+		File-->>BS3: File handle
+		BS3-->>Provider: Database instance
+		Provider->>BS3: pragma('journal_mode = WAL')
+		Note over Provider: connected = true
+		Provider-->>App: callback(null, database)
+	end
+```
+
+---
+
+## Synchronous Query Model
+
+Unlike MySQL and MSSQL providers which use asynchronous APIs, the SQLite provider uses better-sqlite3's synchronous API. Every query blocks the event loop for the duration of the operation, but better-sqlite3's native C++ bindings make individual operations extremely fast.
+
+```mermaid
+flowchart LR
+	subgraph "better-sqlite3 Synchronous API"
+		EXEC["db.exec(sql)<br/>DDL / multi-statement"]
+		PREP["db.prepare(sql)"]
+		RUN["stmt.run(params)<br/>→ { changes, lastInsertRowid }"]
+		GET["stmt.get(params)<br/>→ object | undefined"]
+		ALL["stmt.all(params)<br/>→ array of objects"]
+		TXN["db.transaction(fn)<br/>→ atomic wrapper"]
+	end
+
+	PREP --> RUN
+	PREP --> GET
+	PREP --> ALL
+
+	style EXEC fill:#e8f4e8
+	style RUN fill:#e8f0f8
+	style GET fill:#e8f0f8
+	style ALL fill:#e8f0f8
+	style TXN fill:#f8f0e8
+```
+
+### Query Method Selection
+
+| Goal | Method | Returns |
+|------|--------|---------|
+| Create tables, run DDL | `db.exec(sql)` | nothing |
+| INSERT / UPDATE / DELETE | `db.prepare(sql).run(...)` | `{ changes, lastInsertRowid }` |
+| SELECT one row | `db.prepare(sql).get(...)` | object or `undefined` |
+| SELECT multiple rows | `db.prepare(sql).all(...)` | array of objects |
+| Atomic batch operations | `db.transaction(fn)(args)` | return value of `fn` |
+
+---
+
+## Connection Settings Flow
+
+```mermaid
+flowchart TD
+	FS["fable.settings.SQLite.SQLiteFilePath"]
+	CO["Constructor Options.SQLiteFilePath"]
+	Provider["MeadowConnectionSQLite"]
+	Decision{{"Which source?"}}
+	Use["Use resolved SQLiteFilePath"]
+
+	FS --> Decision
+	CO --> Decision
+	Decision -->|"Options override Settings"| Use
+	Use --> Provider
+```
+
+Settings priority:
+
+1. **Constructor options** — passed as the second argument to `instantiateServiceProvider()`
+2. **Fable settings** — `fable.settings.SQLite.SQLiteFilePath`
+
+Constructor options take priority, allowing multiple provider instances with different database files.
+
+---
+
+## DDL Generation Flow
+
+```mermaid
+flowchart LR
+	Schema["Meadow Table Schema<br/>{ TableName, Columns[] }"]
+	Gen["generateCreateTableStatement()"]
+	DDL["CREATE TABLE IF NOT EXISTS..."]
+	Exec["db.exec(ddl)"]
+	Table["SQLite Table"]
+
+	Schema --> Gen
+	Gen --> DDL
+	DDL --> Exec
+	Exec --> Table
+
+	style Schema fill:#f0f0f0
+	style DDL fill:#e8f4e8
+	style Table fill:#e8f0f8
+```
+
+Each Meadow column type maps to a SQLite storage class:
+
+| Meadow DataType | SQLite Column Definition |
+|-----------------|--------------------------|
+| `ID` | `INTEGER PRIMARY KEY AUTOINCREMENT` |
+| `GUID` | `TEXT DEFAULT '00000000-0000-0000-0000-000000000000'` |
+| `ForeignKey` | `INTEGER NOT NULL DEFAULT 0` |
+| `Numeric` | `INTEGER NOT NULL DEFAULT 0` |
+| `Decimal` | `REAL` |
+| `String` | `TEXT NOT NULL DEFAULT ''` |
+| `Text` | `TEXT` |
+| `DateTime` | `TEXT` |
+| `Boolean` | `INTEGER NOT NULL DEFAULT 0` |
+
+See [Schema & Table Creation](schema.md) for full details.
+
+---
+
+## Connection Safety
+
+```mermaid
+flowchart TD
+	Start["connectAsync() called"]
+	CheckPath{{"SQLiteFilePath<br/>configured?"}}
+	CheckConn{{"Already<br/>connected?"}}
+	Connect["Open database file"]
+	WAL["Enable WAL journaling"]
+	Done["callback(null, db)"]
+	ErrPath["callback(error)"]
+	ErrConn["Log error, callback(null, existingDB)"]
+
+	Start --> CheckPath
+	CheckPath -->|No| ErrPath
+	CheckPath -->|Yes| CheckConn
+	CheckConn -->|Yes| ErrConn
+	CheckConn -->|No| Connect
+	Connect --> WAL
+	WAL --> Done
+
+	style ErrPath fill:#f8e0e0
+	style ErrConn fill:#f8f0e0
+	style Done fill:#e0f8e0
+```
+
+The provider guards against:
+
+- **Missing file path** -- Returns an error immediately if `SQLiteFilePath` is not configured
+- **Double connect** -- Logs an error and returns the existing database if already connected
+- **File creation** -- The database file is created automatically by better-sqlite3 if it does not exist
+
+---
+
+## Meadow Ecosystem Integration
+
+```mermaid
+sequenceDiagram
+	participant App as Application
+	participant Meadow as Meadow ORM
+	participant FH as FoxHound
+	participant Provider as SQLite Provider
+	participant BS3 as better-sqlite3
+	participant File as .db File
+
+	App->>Provider: connectAsync()
+	Provider->>BS3: new Database(path)
+	BS3->>File: Open / create
+	Provider-->>App: Connected
+
+	App->>Meadow: new Meadow(fable, 'Entity')
+	App->>Meadow: setProvider('ALASQL')
+	App->>Meadow: setSchema(columns)
+
+	Note over App,Provider: For schema DDL
+	App->>Provider: createTable(schema)
+	Provider->>Provider: generateCreateTableStatement()
+	Provider->>BS3: db.exec(ddl)
+
+	Note over App,Provider: For direct queries
+	App->>Provider: .db getter
+	Provider-->>App: Database instance
+	App->>BS3: prepare(sql).all()
+	BS3-->>App: Results
+```
+
+The SQLite connection provider serves two roles in the Meadow ecosystem:
+
+1. **Schema DDL** -- Generates and executes `CREATE TABLE` statements from Meadow table schemas
+2. **Direct query access** -- Exposes the `better-sqlite3` database for synchronous query execution
+
+---
+
+## Connector Comparison
+
+| Feature | SQLite | MySQL | MSSQL | RocksDB |
+|---------|--------|-------|-------|---------|
+| **Server Required** | No | Yes | Yes | No |
+| **Query API** | Synchronous | Async (callback) | Async (Promise) | Async (callback) |
+| **File-based** | Yes | No | No | Yes |
+| **In-memory mode** | `:memory:` | No | No | No |
+| **WAL journaling** | Auto-enabled | N/A | N/A | Built-in |
+| **Native driver** | better-sqlite3 | mysql2 | mssql (Tedious) | @nxtedition/rocksdb |
+| **Connection pooling** | No (single file) | Yes | Yes | No (single handle) |
+| **DDL generation** | Yes | Yes | Yes | No |
+| **Prepared statements** | `db.prepare()` | Via pool | `ps.prepare()` | N/A |
+| **Transactions** | `db.transaction(fn)` | Via pool | Via pool | Batch writes |
+| **SQL support** | Full SQLite SQL | Full MySQL SQL | Full T-SQL | Key-value only |
+| **Best for** | Local, embedded, test | Production servers | Enterprise | High-throughput KV |

package/docs/quickstart.md

@@ -0,0 +1,197 @@
+# Quickstart
+
+Get a SQLite database connected and running in five steps.
+
+---
+
+## Step 1 — Install
+
+```bash
+npm install meadow-connection-sqlite fable
+```
+
+`better-sqlite3` compiles a native addon at install time. A C/C++ toolchain must be available on the host (GCC, Clang, or MSVC).
+
+---
+
+## Step 2 — Configure and Connect
+
+```javascript
+const libFable = require('fable');
+const libMeadowConnectionSQLite = require('meadow-connection-sqlite');
+
+let _Fable = new libFable(
+	{
+		"Product": "BookstoreApp",
+		"ProductVersion": "1.0.0",
+		"SQLite":
+		{
+			"SQLiteFilePath": "./data/bookstore.db"
+		}
+	});
+
+_Fable.serviceManager.addServiceType('MeadowSQLiteProvider', libMeadowConnectionSQLite);
+_Fable.serviceManager.instantiateServiceProvider('MeadowSQLiteProvider');
+
+_Fable.MeadowSQLiteProvider.connectAsync(
+	(pError, pDatabase) =>
+	{
+		if (pError)
+		{
+			console.error('Connection failed:', pError);
+			return;
+		}
+
+		console.log('Connected:', _Fable.MeadowSQLiteProvider.connected);
+		// => Connected: true
+	});
+```
+
+The database file is created automatically if it does not exist. WAL journal mode is enabled on connection.
+
+For in-memory databases (useful in tests), set `SQLiteFilePath` to `":memory:"`.
+
+---
+
+## Step 3 — Run Queries
+
+All queries use the synchronous `better-sqlite3` API via the `db` getter:
+
+```javascript
+let tmpDB = _Fable.MeadowSQLiteProvider.db;
+
+// Create a table with raw SQL
+tmpDB.exec(`
+	CREATE TABLE IF NOT EXISTS Book (
+		IDBook INTEGER PRIMARY KEY AUTOINCREMENT,
+		Title TEXT DEFAULT '',
+		Author TEXT DEFAULT '',
+		Price REAL DEFAULT 0.0
+	)
+`);
+
+// Insert a row with a prepared statement
+let tmpInsert = tmpDB.prepare(
+	'INSERT INTO Book (Title, Author, Price) VALUES (?, ?, ?)'
+);
+let tmpResult = tmpInsert.run('Dune', 'Frank Herbert', 14.99);
+console.log('Inserted ID:', tmpResult.lastInsertRowid);
+// => Inserted ID: 1
+
+// Query all rows
+let tmpBooks = tmpDB.prepare('SELECT * FROM Book').all();
+console.log(tmpBooks);
+// => [{ IDBook: 1, Title: 'Dune', Author: 'Frank Herbert', Price: 14.99 }]
+
+// Query a single row
+let tmpBook = tmpDB.prepare('SELECT * FROM Book WHERE IDBook = ?').get(1);
+console.log(tmpBook.Title);
+// => Dune
+```
+
+### Key Methods
+
+| Method | Returns | Purpose |
+|--------|---------|---------|
+| `db.exec(sql)` | nothing | Run DDL or multi-statement SQL |
+| `db.prepare(sql).run(...)` | `{ changes, lastInsertRowid }` | INSERT, UPDATE, DELETE |
+| `db.prepare(sql).get(...)` | object or `undefined` | SELECT single row |
+| `db.prepare(sql).all(...)` | array of objects | SELECT all matching rows |
+| `db.transaction(fn)` | wrapped function | Atomic batch operations |
+
+---
+
+## Step 4 — Create Tables from Schema
+
+Instead of writing DDL by hand, pass a Meadow table schema to `createTable()`:
+
+```javascript
+let tmpBookSchema =
+{
+	TableName: 'Book',
+	Columns:
+	[
+		{ Column: 'IDBook', DataType: 'ID' },
+		{ Column: 'GUIDBook', DataType: 'GUID' },
+		{ Column: 'Title', DataType: 'String', Size: '256' },
+		{ Column: 'Author', DataType: 'String', Size: '128' },
+		{ Column: 'YearPublished', DataType: 'Numeric' },
+		{ Column: 'Price', DataType: 'Decimal', Size: '10,2' },
+		{ Column: 'InPrint', DataType: 'Boolean' },
+		{ Column: 'CreateDate', DataType: 'DateTime' },
+		{ Column: 'UpdateDate', DataType: 'DateTime' }
+	]
+};
+
+_Fable.MeadowSQLiteProvider.createTable(tmpBookSchema,
+	(pError) =>
+	{
+		if (pError) { console.error('Create table failed:', pError); return; }
+		console.log('Table created!');
+	});
+```
+
+You can also generate the DDL string without executing it:
+
+```javascript
+let tmpDDL = _Fable.MeadowSQLiteProvider.generateCreateTableStatement(tmpBookSchema);
+console.log(tmpDDL);
+```
+
+Output:
+
+```sql
+CREATE TABLE IF NOT EXISTS Book (IDBook INTEGER PRIMARY KEY AUTOINCREMENT, GUIDBook TEXT DEFAULT '00000000-0000-0000-0000-000000000000', Title TEXT NOT NULL DEFAULT '', Author TEXT NOT NULL DEFAULT '', YearPublished INTEGER NOT NULL DEFAULT 0, Price REAL, InPrint INTEGER NOT NULL DEFAULT 0, CreateDate TEXT, UpdateDate TEXT);
+```
+
+---
+
+## Step 5 — Meadow ORM Integration
+
+Wire the SQLite connection into Meadow for full ORM capabilities:
+
+```javascript
+const libMeadow = require('meadow');
+
+let tmpBookMeadow = libMeadow.new(_Fable, 'FableTest')
+	.setProvider('ALASQL')
+	.setDefaultIdentifier('IDBook')
+	.loadFromPackage(
+		{
+			scope: 'Book',
+			jsonschema:
+			{
+				title: 'Book',
+				properties:
+				{
+					IDBook: { type: 'integer' },
+					GUIDBook: { type: 'string' },
+					Title: { type: 'string' },
+					Author: { type: 'string' }
+				}
+			}
+		});
+```
+
+> **Note:** Meadow uses FoxHound dialects for query generation. For SQLite-specific workloads that bypass Meadow's query layer, use the `db` getter directly. The ALASQL provider is commonly paired with SQLite for local Meadow operations.
+
+---
+
+## Summary
+
+| Step | What It Does |
+|------|-------------|
+| Install | `npm install meadow-connection-sqlite fable` |
+| Configure | Set `SQLite.SQLiteFilePath` in Fable settings |
+| Connect | `connectAsync()` opens the file and enables WAL |
+| Query | `db.prepare().run/get/all()` for synchronous queries |
+| Schema DDL | `createTable()` generates and executes SQLite DDL |
+
+---
+
+## Next Steps
+
+- [Architecture & Design](architecture.md) -- Connection lifecycle and data flow diagrams
+- [Full Pipeline Example](examples-pipeline.md) -- End-to-end CRUD pipeline with transactions
+- [API Reference](api/reference.md) -- Complete reference for every property and method
+- [Schema & Table Creation](schema.md) -- Column type mapping and DDL generation