@neupgroup/mapper 1.2.0 → 1.2.2

package/dist/config-wrapper.d.ts

@@ -0,0 +1,6 @@
+import { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper } from './config';
+import type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig } from './config';
+export { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper };
+export type { MapperConfig, ConnectionConfig, DatabaseConnectionConfig, ApiConnectionConfig };
+export declare const mapper: ConfigBasedMapper;
+export default mapper;

package/dist/config-wrapper.js

@@ -0,0 +1,7 @@
+import { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper } from './config';
+// Re-export the config-based system as the primary interface
+export { ConfigBasedMapper, createDefaultMapper, createConfigMapper, getConfigMapper };
+// Create and export a default configured mapper instance
+export const mapper = createDefaultMapper();
+// Export the config-based mapper as the default export
+export default mapper;

package/dist/config.d.ts

@@ -0,0 +1,68 @@
+import { Connections, SchemaManager } from './index';
+export interface DatabaseConnectionConfig {
+    name: string;
+    type: 'mysql' | 'sql' | 'firestore' | 'mongodb';
+    host: string;
+    port: number;
+    database: string;
+    user: string;
+    password?: string;
+    ssl?: boolean;
+    [key: string]: any;
+}
+export interface ApiConnectionConfig {
+    name: string;
+    type: 'api';
+    url: string;
+    headers?: Record<string, string>;
+    timeout?: number;
+    [key: string]: any;
+}
+export type ConnectionConfig = DatabaseConnectionConfig | ApiConnectionConfig;
+export interface ConfigSchema {
+    name: string;
+    connection: string;
+    collection: string;
+    structure?: Record<string, string> | Array<{
+        name: string;
+        type: 'string' | 'number' | 'boolean' | 'date' | 'int';
+        [key: string]: any;
+    }>;
+}
+export interface MapperConfig {
+    connections: ConnectionConfig[];
+    schemas?: ConfigSchema[];
+}
+export declare class ConfigLoader {
+    private static instance;
+    private config?;
+    static getInstance(): ConfigLoader;
+    load(config: MapperConfig): void;
+    loadFromFile(path: string): void;
+    getConfig(): MapperConfig | undefined;
+}
+export declare class ConfigBasedMapper {
+    private mapper;
+    private configLoader;
+    private initialized;
+    constructor();
+    configure(config: MapperConfig): this;
+    configureFromFile(path: string): this;
+    private initializeFromConfig;
+    private initializeConnection;
+    private initializeSchema;
+    getConnections(): Connections;
+    getSchemaManager(): SchemaManager;
+    use(schemaName: string): any;
+    schema(name: string): any;
+    connect(name: string, type: 'mysql' | 'sql' | 'firestore' | 'mongodb' | 'api', config: Record<string, any>): import("./mapper").Mapper;
+    get(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any>[]>;
+    getOne(schemaName: string, filters?: Record<string, any>): Promise<Record<string, any> | null>;
+    add(schemaName: string, data: Record<string, any>): Promise<any>;
+    update(schemaName: string, filters: Record<string, any>, data: Record<string, any>): Promise<void>;
+    delete(schemaName: string, filters: Record<string, any>): Promise<void>;
+}
+export declare function createConfigMapper(config?: MapperConfig): ConfigBasedMapper;
+export declare function getConfigMapper(): ConfigBasedMapper;
+export declare function createDefaultMapper(config?: MapperConfig): ConfigBasedMapper;
+export default ConfigBasedMapper;

package/dist/config.js

@@ -0,0 +1,234 @@
+import { createMapper } from './mapper';
+export class ConfigLoader {
+    static getInstance() {
+        if (!ConfigLoader.instance) {
+            ConfigLoader.instance = new ConfigLoader();
+        }
+        return ConfigLoader.instance;
+    }
+    load(config) {
+        this.config = config;
+    }
+    loadFromFile(path) {
+        try {
+            // In Node.js environment
+            if (typeof require !== 'undefined') {
+                const fs = require('fs');
+                const configData = fs.readFileSync(path, 'utf8');
+                this.config = JSON.parse(configData);
+            }
+            else {
+                // In browser environment, fetch the config file
+                fetch(path)
+                    .then(response => response.json())
+                    .then(config => {
+                    this.config = config;
+                })
+                    .catch((error) => {
+                    throw new Error(`Failed to load config from ${path}: ${error.message}`);
+                });
+            }
+        }
+        catch (error) {
+            throw new Error(`Failed to load config from ${path}: ${error.message}`);
+        }
+    }
+    getConfig() {
+        return this.config;
+    }
+}
+export class ConfigBasedMapper {
+    constructor() {
+        this.initialized = false;
+        this.mapper = createMapper();
+        this.configLoader = ConfigLoader.getInstance();
+    }
+    configure(config) {
+        this.configLoader.load(config);
+        this.initializeFromConfig();
+        return this;
+    }
+    configureFromFile(path) {
+        this.configLoader.loadFromFile(path);
+        this.initializeFromConfig();
+        return this;
+    }
+    initializeFromConfig() {
+        const config = this.configLoader.getConfig();
+        if (!config) {
+            throw new Error('No configuration loaded');
+        }
+        // Initialize connections
+        for (const connectionConfig of config.connections) {
+            this.initializeConnection(connectionConfig);
+        }
+        // Initialize schemas
+        if (config.schemas) {
+            for (const schemaConfig of config.schemas) {
+                this.initializeSchema(schemaConfig);
+            }
+        }
+        this.initialized = true;
+    }
+    initializeConnection(config) {
+        const { name, type } = config;
+        if (type === 'api') {
+            const apiConfig = config;
+            this.mapper.connect(name, type, apiConfig);
+        }
+        else {
+            const dbConfig = config;
+            this.mapper.connect(name, type, dbConfig);
+        }
+    }
+    initializeSchema(config) {
+        const schemaBuilder = this.mapper.schema(config.name);
+        schemaBuilder.use({ connection: config.connection, collection: config.collection });
+        if (config.structure) {
+            schemaBuilder.setStructure(config.structure);
+        }
+    }
+    // Delegate methods to the underlying mapper
+    getConnections() {
+        return this.mapper.getConnections();
+    }
+    getSchemaManager() {
+        return this.mapper.getSchemaManager();
+    }
+    use(schemaName) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.use(schemaName);
+    }
+    schema(name) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.schema(name);
+    }
+    connect(name, type, config) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.connect(name, type, config);
+    }
+    // Quick query methods
+    async get(schemaName, filters) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.get(schemaName, filters);
+    }
+    async getOne(schemaName, filters) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.getOne(schemaName, filters);
+    }
+    async add(schemaName, data) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.add(schemaName, data);
+    }
+    async update(schemaName, filters, data) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.update(schemaName, filters, data);
+    }
+    async delete(schemaName, filters) {
+        if (!this.initialized) {
+            throw new Error('Mapper not initialized. Call configure() first.');
+        }
+        return this.mapper.delete(schemaName, filters);
+    }
+}
+// Create a default instance
+let defaultConfigMapper = null;
+export function createConfigMapper(config) {
+    const mapper = new ConfigBasedMapper();
+    if (config) {
+        mapper.configure(config);
+    }
+    defaultConfigMapper = mapper;
+    return mapper;
+}
+// Export a function to get the default instance
+export function getConfigMapper() {
+    if (!defaultConfigMapper) {
+        defaultConfigMapper = new ConfigBasedMapper();
+    }
+    return defaultConfigMapper;
+}
+// Create a default configured mapper instance
+export function createDefaultMapper(config) {
+    const mapper = new ConfigBasedMapper();
+    // If no config provided, try to load from environment or default locations
+    if (!config) {
+        // Try to load from environment
+        const envConfig = loadConfigFromEnvironment();
+        if (envConfig) {
+            mapper.configure(envConfig);
+        }
+        else {
+            // Try to load from default config file locations
+            const defaultPaths = ['./mapper.config.json', './config/mapper.json', '/etc/mapper/config.json'];
+            for (const path of defaultPaths) {
+                try {
+                    mapper.configureFromFile(path);
+                    break;
+                }
+                catch (error) {
+                    // Continue trying other paths
+                }
+            }
+        }
+    }
+    else {
+        mapper.configure(config);
+    }
+    return mapper;
+}
+function loadConfigFromEnvironment() {
+    if (typeof process !== 'undefined' && process.env) {
+        // Check for MAPPER_CONFIG environment variable
+        const envConfig = process.env.MAPPER_CONFIG;
+        if (envConfig) {
+            try {
+                return JSON.parse(envConfig);
+            }
+            catch (error) {
+                console.warn('Failed to parse MAPPER_CONFIG environment variable:', error);
+            }
+        }
+        // Check for individual database connection environment variables
+        const databaseUrl = process.env.DATABASE_URL;
+        if (databaseUrl) {
+            return {
+                connections: [{
+                        name: 'default',
+                        type: inferConnectionType(databaseUrl),
+                        host: databaseUrl,
+                        port: 5432,
+                        database: 'default',
+                        user: 'default'
+                    }]
+            };
+        }
+    }
+    return null;
+}
+function inferConnectionType(url) {
+    if (url.includes('mysql'))
+        return 'mysql';
+    if (url.includes('postgres') || url.includes('postgresql'))
+        return 'sql';
+    if (url.includes('mongodb'))
+        return 'mongodb';
+    if (url.includes('firestore'))
+        return 'firestore';
+    return 'sql'; // default to sql
+}
+export default ConfigBasedMapper;

package/dist/docs.d.ts

@@ -0,0 +1,3 @@
+export declare const documentationMd = "\n# Mapper Library Documentation\n\nWelcome to `@neupgroup/mapper`. This guide covers:\n- Installation\n- Configuring connections (DSL and UI)\n- Using connections in code\n- Creating schemas (ORM)\n- Configuring and using schemas\n- CRUD operations: insert, update, delete, fetch\n- Error handling and troubleshooting\n\n---\n\n## Installation\n\n- Install from npm:\n  `npm install @neupgroup/mapper`\n- In this workspace, the app depends on the library via `workspace:*`. Build the library when you update it:\n  `cd library && npm run build`\n- Import helpers:\n  `import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'`\n\n---\n\n## Configure Connections\n\nYou can configure connections in two ways:\n\n1) DSL File (recommended)\n2) UI Configure page (runtime setup)\n\n### 1) DSL Format\n\nCreate `connections.dsl` at your project root:\n\n```\nconnections = [\n  mysql_prod: {\n    type: mysql\n    host: 127.0.0.1\n    port: 3306\n    user: root\n    password: \"s3cr3t\"\n    database: appdb\n  }\n\n  mongo_dev: {\n    type: mongodb\n    uri: \"mongodb://127.0.0.1:27017\"\n    database: devdb\n  }\n\n  firestore_local: {\n    type: firestore\n    projectId: my-project\n    applicationDefault: true\n  }\n\n  http_api: {\n    type: api\n    baseUrl: \"https://api.example.com\"\n    token: \"abc123\"\n  }\n]\n```\n\nNotes:\n- `type` (or `dbType`) defaults to `api` if omitted.\n- Values can be unquoted or quoted; comments using `#` are ignored.\n\nParse and normalize:\n\n```ts\nimport { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'\n\nconst text = await fs.promises.readFile('connections.dsl', 'utf8')\nconst envMap = parseConnectionsDsl(text)\nconst connections = toNormalizedConnections(envMap)\n// connections: Array<{ name, type, key }>\n```\n\n### 2) UI Configure Page\n\n- Go to `/configure` to define connections at runtime.\n- Use \"Generate collective env\" to produce `connections.dsl` from configured connections.\n- Download the file and commit it or load at startup.\n\n---\n\n## Use Connections in Code\n\n### Normalize and route by type\n\n```ts\nimport { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'\nimport { connection, schema } from '@neupgroup/mapper'\n\nconst text = await fs.promises.readFile('connections.dsl', 'utf8')\nconst envMap = parseConnectionsDsl(text)\nconst conns = toNormalizedConnections(envMap)\n\n// Register connections\nconst conRegistry = connection()\nfor (const c of conns) {\n  conRegistry.register({ name: c.name, type: c.type, key: c.key })\n}\n\n// Use with schemas\nconst sm = schema(conRegistry)\n```\n\n### Direct construction\n\n```ts\nconst conRegistry = connection()\nconRegistry.create('mysql_prod', 'mysql').key({\n  host: '127.0.0.1',\n  port: 3306,\n  user: 'root',\n  password: 's3cr3t',\n  database: 'appdb',\n})\n```\n\n---\n\n## Schemas and Models\n\nSchemas define structure for collections/tables bound to a connection.\n\n### Define and register a schema\n\n```ts\nimport { schema } from '@neupgroup/mapper'\n\nconst sm = schema(conRegistry)\n\nsm.create('User')\n  .use({ connection: 'mysql_prod', collection: 'users' })\n  .setStructure({\n    id: 'string primary',\n    email: 'string unique',\n    name: 'string editable',\n    createdAt: 'date',\n    '?field': 'allow-undefined', // optional: permit fields not listed\n  })\n\nconst User = sm.use('User')\n```\n\n---\n\n## CRUD Operations\n\nAll operations return Promises and may throw on errors.\n\n### Insert\n\n```ts\nconst createdId = await User.add({\n  id: 'u_123',\n  email: 'alice@example.com',\n  name: 'Alice',\n  createdAt: new Date(),\n})\n```\n\n### Update\n\n```ts\nawait User.where(['id', 'u_123']).to({ name: 'Alice Cooper' }).updateOne()\n```\n\n### Delete\n\n```ts\nawait User.where(['id', 'u_123']).deleteOne()\n```\n\n### Fetch / Query\n\n```ts\nconst one = await User.where(['id', 'u_123']).getOne()\nconst many = await User.where('email', '%@example.com', 'like').get()\n```\n\n---\n\n## Schema Configuration Details\n\n- `primary`: marks primary key; used for updates/deletes.\n- `unique`: enforces uniqueness in supported backends.\n- `editable`: indicates fields commonly modified via UI.\n- `type`: one of `string`, `number`, `boolean`, `date`, `int`.\n- `?field`: enables accepting fields not defined in the schema.\n\n---\n\n## Error Handling\n\nWrap operations in `try/catch` and inspect known error shapes.\n\n```ts\ntry {\n  const user = await User.where(['id', 'u_404']).getOne()\n  if (!user) {\n    // handle not found gracefully\n  }\n} catch (err) {\n  if (err && typeof err === 'object' && 'code' in err) {\n    console.error('Database error code:', (err as any).code)\n  }\n  console.error('Unexpected error', err)\n}\n```\n\nRecommendations:\n- Validate required creds before initializing connections.\n- Prefer parameterized queries or ORM filters over string concatenation.\n- Log request IDs and timestamps for audit trails.\n\n---\n\n## Troubleshooting\n\n- \"Connection refused\": check host/port/firewall and credentials.\n- \"Authentication failed\": verify tokens/passwords and token scopes.\n- \"Timeout\": review network paths and optimize query.\n- \"Schema mismatch\": ensure field names/types match the backend.\n\n---\n\n## API Quick Reference\n\n- `parseConnectionsDsl(text)` \u2192 Map of connectionName \u2192 key/value creds\n- `toNormalizedConnections(map)` \u2192 Array of { name, type, key }\n- `connection()` \u2192 Connection registry (create/register/list/get)\n- `schema(connections?)` \u2192 Schema manager; define, register, and use schemas\n\n---\n\n## End-to-End Example\n\n```ts\nimport { parseConnectionsDsl, toNormalizedConnections, connection, schema } from '@neupgroup/mapper'\n\nconst text = await fs.promises.readFile('connections.dsl', 'utf8')\nconst map = parseConnectionsDsl(text)\nconst conns = toNormalizedConnections(map)\n\nconst conRegistry = connection()\nfor (const c of conns) conRegistry.register({ name: c.name, type: c.type, key: c.key })\n\nconst sm = schema(conRegistry)\nsm.create('Product')\n  .use({ connection: conns[0].name, collection: 'products' })\n  .setStructure({\n    id: 'string primary',\n    title: 'string',\n    price: 'number',\n    tags: 'string',\n  })\nconst Product = sm.use('Product')\n\nawait Product.add({ id: 'p_1', title: 'Widget', price: 9.99, tags: 'sale' })\nawait Product.where(['id', 'p_1']).to({ price: 7.99 }).updateOne()\nconst items = await Product.where('price', 10, '<').get()\nawait Product.where(['id', 'p_1']).deleteOne()\n```\n";
+export declare function markdownToHtml(md: string): string;
+export declare function getDocumentationHtml(): string;

package/dist/docs.js

@@ -0,0 +1,351 @@
+// Centralized documentation for @neupgroup/mapper.
+// Exports Markdown plus a minimal Markdown→HTML converter so apps can render
+// without a heavy dependency. Keep content comprehensive and up-to-date.
+export const documentationMd = `
+# Mapper Library Documentation
+
+Welcome to \`@neupgroup/mapper\`. This guide covers:
+- Installation
+- Configuring connections (DSL and UI)
+- Using connections in code
+- Creating schemas (ORM)
+- Configuring and using schemas
+- CRUD operations: insert, update, delete, fetch
+- Error handling and troubleshooting
+
+---
+
+## Installation
+
+- Install from npm:
+  \`npm install @neupgroup/mapper\`
+- In this workspace, the app depends on the library via \`workspace:*\`. Build the library when you update it:
+  \`cd library && npm run build\`
+- Import helpers:
+  \`import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'\`
+
+---
+
+## Configure Connections
+
+You can configure connections in two ways:
+
+1) DSL File (recommended)
+2) UI Configure page (runtime setup)
+
+### 1) DSL Format
+
+Create \`connections.dsl\` at your project root:
+
+\`\`\`
+connections = [
+  mysql_prod: {
+    type: mysql
+    host: 127.0.0.1
+    port: 3306
+    user: root
+    password: "s3cr3t"
+    database: appdb
+  }
+
+  mongo_dev: {
+    type: mongodb
+    uri: "mongodb://127.0.0.1:27017"
+    database: devdb
+  }
+
+  firestore_local: {
+    type: firestore
+    projectId: my-project
+    applicationDefault: true
+  }
+
+  http_api: {
+    type: api
+    baseUrl: "https://api.example.com"
+    token: "abc123"
+  }
+]
+\`\`\`
+
+Notes:
+- \`type\` (or \`dbType\`) defaults to \`api\` if omitted.
+- Values can be unquoted or quoted; comments using \`#\` are ignored.
+
+Parse and normalize:
+
+\`\`\`ts
+import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'
+
+const text = await fs.promises.readFile('connections.dsl', 'utf8')
+const envMap = parseConnectionsDsl(text)
+const connections = toNormalizedConnections(envMap)
+// connections: Array<{ name, type, key }>
+\`\`\`
+
+### 2) UI Configure Page
+
+- Go to \`/configure\` to define connections at runtime.
+- Use \"Generate collective env\" to produce \`connections.dsl\` from configured connections.
+- Download the file and commit it or load at startup.
+
+---
+
+## Use Connections in Code
+
+### Normalize and route by type
+
+\`\`\`ts
+import { parseConnectionsDsl, toNormalizedConnections } from '@neupgroup/mapper'
+import { connection, schema } from '@neupgroup/mapper'
+
+const text = await fs.promises.readFile('connections.dsl', 'utf8')
+const envMap = parseConnectionsDsl(text)
+const conns = toNormalizedConnections(envMap)
+
+// Register connections
+const conRegistry = connection()
+for (const c of conns) {
+  conRegistry.register({ name: c.name, type: c.type, key: c.key })
+}
+
+// Use with schemas
+const sm = schema(conRegistry)
+\`\`\`
+
+### Direct construction
+
+\`\`\`ts
+const conRegistry = connection()
+conRegistry.create('mysql_prod', 'mysql').key({
+  host: '127.0.0.1',
+  port: 3306,
+  user: 'root',
+  password: 's3cr3t',
+  database: 'appdb',
+})
+\`\`\`
+
+---
+
+## Schemas and Models
+
+Schemas define structure for collections/tables bound to a connection.
+
+### Define and register a schema
+
+\`\`\`ts
+import { schema } from '@neupgroup/mapper'
+
+const sm = schema(conRegistry)
+
+sm.create('User')
+  .use({ connection: 'mysql_prod', collection: 'users' })
+  .setStructure({
+    id: 'string primary',
+    email: 'string unique',
+    name: 'string editable',
+    createdAt: 'date',
+    '?field': 'allow-undefined', // optional: permit fields not listed
+  })
+
+const User = sm.use('User')
+\`\`\`
+
+---
+
+## CRUD Operations
+
+All operations return Promises and may throw on errors.
+
+### Insert
+
+\`\`\`ts
+const createdId = await User.add({
+  id: 'u_123',
+  email: 'alice@example.com',
+  name: 'Alice',
+  createdAt: new Date(),
+})
+\`\`\`
+
+### Update
+
+\`\`\`ts
+await User.where(['id', 'u_123']).to({ name: 'Alice Cooper' }).updateOne()
+\`\`\`
+
+### Delete
+
+\`\`\`ts
+await User.where(['id', 'u_123']).deleteOne()
+\`\`\`
+
+### Fetch / Query
+
+\`\`\`ts
+const one = await User.where(['id', 'u_123']).getOne()
+const many = await User.where('email', '%@example.com', 'like').get()
+\`\`\`
+
+---
+
+## Schema Configuration Details
+
+- \`primary\`: marks primary key; used for updates/deletes.
+- \`unique\`: enforces uniqueness in supported backends.
+- \`editable\`: indicates fields commonly modified via UI.
+- \`type\`: one of \`string\`, \`number\`, \`boolean\`, \`date\`, \`int\`.
+- \`?field\`: enables accepting fields not defined in the schema.
+
+---
+
+## Error Handling
+
+Wrap operations in \`try/catch\` and inspect known error shapes.
+
+\`\`\`ts
+try {
+  const user = await User.where(['id', 'u_404']).getOne()
+  if (!user) {
+    // handle not found gracefully
+  }
+} catch (err) {
+  if (err && typeof err === 'object' && 'code' in err) {
+    console.error('Database error code:', (err as any).code)
+  }
+  console.error('Unexpected error', err)
+}
+\`\`\`
+
+Recommendations:
+- Validate required creds before initializing connections.
+- Prefer parameterized queries or ORM filters over string concatenation.
+- Log request IDs and timestamps for audit trails.
+
+---
+
+## Troubleshooting
+
+- \"Connection refused\": check host/port/firewall and credentials.
+- \"Authentication failed\": verify tokens/passwords and token scopes.
+- \"Timeout\": review network paths and optimize query.
+- \"Schema mismatch\": ensure field names/types match the backend.
+
+---
+
+## API Quick Reference
+
+- \`parseConnectionsDsl(text)\` → Map of connectionName → key/value creds
+- \`toNormalizedConnections(map)\` → Array of { name, type, key }
+- \`connection()\` → Connection registry (create/register/list/get)
+- \`schema(connections?)\` → Schema manager; define, register, and use schemas
+
+---
+
+## End-to-End Example
+
+\`\`\`ts
+import { parseConnectionsDsl, toNormalizedConnections, connection, schema } from '@neupgroup/mapper'
+
+const text = await fs.promises.readFile('connections.dsl', 'utf8')
+const map = parseConnectionsDsl(text)
+const conns = toNormalizedConnections(map)
+
+const conRegistry = connection()
+for (const c of conns) conRegistry.register({ name: c.name, type: c.type, key: c.key })
+
+const sm = schema(conRegistry)
+sm.create('Product')
+  .use({ connection: conns[0].name, collection: 'products' })
+  .setStructure({
+    id: 'string primary',
+    title: 'string',
+    price: 'number',
+    tags: 'string',
+  })
+const Product = sm.use('Product')
+
+await Product.add({ id: 'p_1', title: 'Widget', price: 9.99, tags: 'sale' })
+await Product.where(['id', 'p_1']).to({ price: 7.99 }).updateOne()
+const items = await Product.where('price', 10, '<').get()
+await Product.where(['id', 'p_1']).deleteOne()
+\`\`\`
+`;
+// Minimal Markdown → HTML converter (headings, lists, code fences, inline code, paragraphs)
+export function markdownToHtml(md) {
+    const lines = md.split(/\r?\n/);
+    let html = [];
+    let inCode = false;
+    let codeBuf = [];
+    function escapeHtml(s) {
+        return s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
+    }
+    function inline(s) {
+        s = s.replace(/`([^`]+)`/g, (_m, g1) => `<code>${escapeHtml(g1)}</code>`);
+        s = s.replace(/\*\*([^*]+)\*\*/g, '<strong>$1</strong>');
+        s = s.replace(/\*([^*]+)\*/g, '<em>$1</em>');
+        s = s.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '<a href="$2">$1</a>');
+        return s;
+    }
+    function flushParagraph(buf) {
+        const text = buf.join(' ').trim();
+        if (!text)
+            return;
+        html.push(`<p>${inline(escapeHtml(text))}</p>`);
+        buf.length = 0;
+    }
+    let paraBuf = [];
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        if (line.trim().startsWith('```')) {
+            if (inCode) {
+                html.push(`<pre><code>${escapeHtml(codeBuf.join('\n'))}</code></pre>`);
+                codeBuf = [];
+                inCode = false;
+            }
+            else {
+                flushParagraph(paraBuf);
+                inCode = true;
+            }
+            continue;
+        }
+        if (inCode) {
+            codeBuf.push(line);
+            continue;
+        }
+        const hMatch = /^(#{1,6})\s+(.*)$/.exec(line);
+        if (hMatch) {
+            flushParagraph(paraBuf);
+            const level = hMatch[1].length;
+            const content = hMatch[2];
+            html.push(`<h${level}>${inline(escapeHtml(content))}</h${level}>`);
+            continue;
+        }
+        if (/^\s*[-*]\s+/.test(line)) {
+            flushParagraph(paraBuf);
+            let ulItems = [];
+            ulItems.push(line.replace(/^\s*[-*]\s+/, ''));
+            while (i + 1 < lines.length && /^\s*[-*]\s+/.test(lines[i + 1])) {
+                i++;
+                ulItems.push(lines[i].replace(/^\s*[-*]\s+/, ''));
+            }
+            const lis = ulItems.map(item => `<li>${inline(escapeHtml(item))}</li>`).join('');
+            html.push(`<ul>${lis}</ul>`);
+            continue;
+        }
+        if (/^\s*$/.test(line)) {
+            flushParagraph(paraBuf);
+            continue;
+        }
+        paraBuf.push(line);
+    }
+    if (inCode) {
+        html.push(`<pre><code>${codeBuf.map(s => s.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')).join('\n')}</code></pre>`);
+    }
+    flushParagraph(paraBuf);
+    return html.join('\n');
+}
+export function getDocumentationHtml() {
+    return markdownToHtml(documentationMd);
+}