@forgebase/database 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 ForgeBase
+
+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

@@ -0,0 +1,470 @@
+# ForgeBase Database
+
+A flexible, powerful database abstraction layer for ForgeBase, providing database operations, schema management, row-level security (RLS), and real-time capabilities.
+
+## Features
+
+- 🔄 **Multiple Database Support**: Works with SQLite, PostgreSQL, MySQL, MSSQL, and any Knex-compatible database
+- 🔒 **Row-Level Security (RLS)**: Fine-grained access control at the row level
+- 🔐 **Permission Management**: Role-based access control for tables and operations
+- 📊 **Schema Management**: Create, modify, and delete tables and columns dynamically
+- 🔍 **Query Builder**: Powerful query building with filtering, sorting, and pagination
+- ⚡ **Real-time Updates**: Optional real-time database changes via WebSockets
+- 🧩 **Type Safety**: Full TypeScript support with type definitions
+- 🔌 **Adapter System**: Extensible adapter system for different database engines
+- 🪝 **Event Hooks**: Before/After hooks for queries and mutations
+- 🔎 **Database Inspection**: Retrieve complete database schema and structure
+- 🔄 **Integration Options**: Use with API package, frontend SDK, REST API, or custom frameworks
+
+## Installation
+
+```bash
+npm install @forgebase/database
+# or
+yarn add @forgebase/database
+# or
+pnpm add @forgebase/database
+```
+
+## Basic Usage
+
+### Initialize the Database
+
+```typescript
+import { ForgeDatabase } from '@forgebase/database';
+import knex from 'knex';
+
+// Create a Knex instance
+const knexInstance = knex({
+  client: 'sqlite3',
+  connection: {
+    filename: './mydb.sqlite',
+  },
+  useNullAsDefault: true,
+});
+
+// Initialize ForgeDatabase
+const db = new ForgeDatabase({
+  db: knexInstance,
+  enforceRls: true, // Enable row-level security
+  realtime: true, // Enable real-time updates
+});
+```
+
+### Schema Operations
+
+```typescript
+// Create a new table
+await db.endpoints.schema.create({
+  tableName: 'users',
+  columns: [
+    { name: 'id', type: 'increments', primary: true },
+    { name: 'username', type: 'string', unique: true, nullable: false },
+    { name: 'email', type: 'string', unique: true, nullable: false },
+    { name: 'password', type: 'string', nullable: false },
+    { name: 'role', type: 'string', defaultValue: 'user' },
+    { name: 'created_at', type: 'timestamp', defaultToNow: true },
+  ],
+});
+
+// Get database schema
+const schema = await db.endpoints.schema.get();
+console.log(schema);
+
+// Modify a table
+await db.endpoints.schema.modify({
+  tableName: 'users',
+  addColumns: [{ name: 'last_login', type: 'timestamp', nullable: true }],
+  dropColumns: ['unused_column'],
+  modifyColumns: [{ name: 'role', type: 'string', defaultValue: 'member' }],
+});
+```
+
+### Data Operations
+
+```typescript
+// Query data
+const users = await db.endpoints.data.query(
+  'users',
+  {
+    select: ['id', 'username', 'email', 'role'],
+    where: { role: 'admin' },
+    orderBy: [{ column: 'created_at', direction: 'desc' }],
+    limit: 10,
+    offset: 0,
+  },
+  { id: 1, role: 'admin' }, // User context for RLS
+);
+
+// Create data
+const newUser = await db.endpoints.data.create(
+  {
+    tableName: 'users',
+    data: {
+      username: 'johndoe',
+      email: 'john@example.com',
+      password: 'hashedpassword',
+      role: 'user',
+    },
+  },
+  { id: 1, role: 'admin' }, // User context for RLS
+);
+
+// Update data
+await db.endpoints.data.update(
+  {
+    tableName: 'users',
+    id: 1,
+    data: {
+      role: 'moderator',
+    },
+  },
+  { id: 1, role: 'admin' }, // User context for RLS
+);
+
+// Delete data
+await db.endpoints.data.delete(
+  {
+    tableName: 'users',
+    id: 1,
+  },
+  { id: 1, role: 'admin' }, // User context for RLS
+);
+```
+
+### Permissions Management
+
+```typescript
+// Get permissions for a table
+const permissions = await db.getPermissionService().getPermissionsForTable('users');
+
+// Set permissions for a table
+await db.setPermissions('users', {
+  operations: {
+    SELECT: [
+      // Allow authenticated users to see their own data
+      {
+        allow: 'auth',
+        fieldCheck: {
+          field: 'id',
+          operator: '===',
+          valueType: 'userContext',
+          value: 'userId',
+        },
+      },
+      // Allow admins and moderators to see all data
+      {
+        allow: 'role',
+        roles: ['admin', 'moderator'],
+      },
+      // Allow users with specific labels
+      {
+        allow: 'labels',
+        labels: ['user_manager'],
+      },
+      // Allow users in specific teams
+      {
+        allow: 'teams',
+        teams: ['support_team'],
+      },
+    ],
+    INSERT: [
+      // Only admins can create users
+      {
+        allow: 'role',
+        roles: ['admin'],
+      },
+    ],
+    UPDATE: [
+      // Users can update their own data
+      {
+        allow: 'auth',
+        fieldCheck: {
+          field: 'id',
+          operator: '===',
+          valueType: 'userContext',
+          value: 'userId',
+        },
+      },
+      // Admins and moderators can update any user
+      {
+        allow: 'role',
+        roles: ['admin', 'moderator'],
+      },
+    ],
+    DELETE: [
+      // Only admins can delete users
+      {
+        allow: 'role',
+        roles: ['admin'],
+      },
+      // Custom SQL condition for complex rules
+      {
+        allow: 'customSql',
+        customSql: `
+          SELECT 1 WHERE
+            EXISTS (SELECT 1 FROM user_managers WHERE manager_id = :userId AND user_id = users.id)
+        `,
+      },
+    ],
+  },
+});
+```
+
+### Transactions
+
+ForgeBase Database supports transactions to ensure data consistency and atomicity. All database operations support transactions, allowing you to perform multiple operations as a single unit of work.
+
+There are two ways to use transactions:
+
+#### Explicit Transactions
+
+Pass a transaction object to each method:
+
+```typescript
+// Execute operations in a transaction
+await db.transaction(async (trx) => {
+  // Create a user
+  const user = await db.endpoints.data.create(
+    {
+      tableName: 'users',
+      data: { username: 'jane', email: 'jane@example.com', password: 'hashedpw' },
+    },
+    { id: 1, role: 'admin' },
+    false, // Not a system operation
+    trx, // Pass the transaction
+  );
+
+  // Create a profile for the user
+  await db.endpoints.data.create(
+    {
+      tableName: 'profiles',
+      data: { user_id: user.id, bio: 'New user' },
+    },
+    { id: 1, role: 'admin' },
+    false,
+    trx,
+  );
+});
+```
+
+#### Implicit Transactions
+
+Many methods automatically create a transaction if one isn't provided:
+
+```typescript
+// This will automatically create a transaction internally
+const user = await db.endpoints.data.create(
+  {
+    tableName: 'users',
+    data: { username: 'john', email: 'john@example.com', password: 'hashedpw' },
+  },
+  { id: 1, role: 'admin' },
+);
+```
+
+## Security Best Practices
+
+### Row-Level Security (RLS)
+
+ForgeBase Database provides powerful row-level security capabilities that allow you to define fine-grained access control rules at the row level. There are several ways to implement RLS:
+
+#### Basic RLS with Field Checks
+
+```typescript
+// Enable RLS
+const db = new ForgeDatabase({
+  enforceRls: true,
+  // ...
+});
+
+// Set row-level policies
+await db.setPermissions('documents', {
+  operations: {
+    SELECT: [
+      {
+        allow: 'auth',
+        fieldCheck: {
+          field: 'owner_id',
+          operator: '===',
+          valueType: 'userContext',
+          value: 'userId',
+        },
+      },
+    ],
+  },
+});
+```
+
+#### Advanced RLS with Custom SQL
+
+For complex permission rules that require database queries:
+
+```typescript
+// Example: Limit free users to 5 CVs, but allow pro users unlimited CVs
+await db.setPermissions('cvs', {
+  operations: {
+    INSERT: [
+      {
+        allow: 'customSql',
+        customSql: `
+          SELECT 1 WHERE
+            -- Check if user is on pro plan
+            EXISTS (SELECT 1 FROM subscriptions WHERE user_id = :userId AND plan_type = 'pro')
+            -- OR check if user is on free plan but has fewer than 5 CVs
+            OR (
+              NOT EXISTS (SELECT 1 FROM subscriptions WHERE user_id = :userId AND plan_type = 'pro')
+              AND (SELECT COUNT(*) FROM cvs WHERE user_id = :userId) < 5
+            )
+        `,
+      },
+    ],
+  },
+});
+```
+
+#### Advanced RLS with Custom Functions
+
+For the most flexible permission rules, you can register custom JavaScript functions:
+
+```typescript
+// Register a custom RLS function
+import { rlsFunctionRegistry } from '@forgebase/database';
+
+// Register a function that checks subscription limits
+rlsFunctionRegistry.register('checkSubscriptionLimits', async (userContext, row, knex) => {
+  if (!knex) return false;
+
+  // Check if user is on pro plan
+  const proSub = await knex('subscriptions').where({ user_id: userContext.userId, plan_type: 'pro' }).first();
+
+  if (proSub) return true; // Pro users can create unlimited resources
+
+  // For free users, check resource count
+  const count = await knex('cvs').where({ user_id: userContext.userId }).count('id as count').first();
+
+  return count && count.count < 5; // Allow if less than 5 resources
+});
+
+// Use the registered function in permissions
+await db.setPermissions('cvs', {
+  operations: {
+    INSERT: [
+      {
+        allow: 'customFunction',
+        customFunction: 'checkSubscriptionLimits',
+      },
+    ],
+  },
+});
+```
+
+### Automatic Permission Initialization
+
+ForgeBase Database can automatically initialize permissions for all tables in your database. This feature is useful when you want to ensure that all tables have at least basic permissions set.
+
+#### Configuration
+
+You can enable automatic permission initialization when creating the ForgeDatabase instance:
+
+```typescript
+const db = new ForgeDatabase({
+  db: knexInstance,
+  // Enable automatic permission initialization
+  initializePermissions: true,
+  // Optional: Specify where to save the initialization report
+  permissionReportPath: './permission-report.md',
+  // Optional: Callback function when initialization completes
+  onPermissionInitComplete: (report) => {
+    console.log(`Initialized permissions for ${report.tablesInitialized} tables`);
+  },
+});
+```
+
+#### Manual Initialization
+
+You can also manually trigger permission initialization at any time:
+
+```typescript
+// Initialize permissions with default options from config
+db.initializePermissions();
+
+// Or specify custom options
+db.initializePermissions('./custom-report-path.md', (report) => {
+  console.log('Permission initialization completed!');
+  console.log(`Tables initialized: ${report.initializedTables.join(', ')}`);
+});
+```
+
+### Real-time Updates
+
+When enabled, ForgeBase Database can provide real-time updates via WebSockets:
+
+```typescript
+// Enable real-time updates when initializing
+const db = new ForgeDatabase({
+  db: knexInstance,
+  realtime: true,
+  websocketPort: 8080, // Optional, defaults to 8080
+});
+
+// The WebSocket server will automatically broadcast changes to connected clients
+```
+
+## Frontend Integration
+
+ForgeBase Database can be easily integrated with frontend applications using the `@forgebase/sdk` package:
+
+```typescript
+// Initialize the SDK with your API URL
+import { DatabaseSDK } from '@forgebase/sdk/client';
+
+const db = new DatabaseSDK({
+  baseUrl: 'http://localhost:3000/api',
+  axiosConfig: {
+    withCredentials: true, // Important for auth cookies
+  },
+});
+
+// Query data with a fluent API
+const users = await db.table('users').select('id', 'name', 'email').where('status', 'active').orderBy('name', 'asc').query();
+
+// Create a new record
+const newUser = await db.table('users').create({
+  name: 'John Doe',
+  email: 'john@example.com',
+  role: 'user',
+});
+
+// Update a record
+await db.table('users').update(123, {
+  name: 'John Smith',
+});
+
+// Delete a record
+await db.table('users').delete(123);
+
+// Real-time updates
+const unsubscribe = db.table('users').subscribe((event) => {
+  if (event.type === 'create') {
+    console.log('New user created:', event.record);
+  } else if (event.type === 'update') {
+    console.log('User updated:', event.record);
+  } else if (event.type === 'delete') {
+    console.log('User deleted:', event.id);
+  }
+});
+
+// Later, unsubscribe when no longer needed
+unsubscribe();
+```
+
+For more details on integration options, see the [Complete Integration](/database/complete-integration) guide.
+
+## API Reference
+
+For detailed API documentation, please refer to the [ForgeBase Documentation](https://docs.forgebase.dev/database).
+
+## License
+
+[MIT](https://github.com/The-ForgeBase/forgebase-ts/blob/main/LICENSE)

package/dist/cjs/adapters/base.d.ts

@@ -0,0 +1,20 @@
+import { WindowFunction, OrderByClause } from '../sdk/server';
+export interface DatabaseAdapter {
+    buildWindowFunction(wf: WindowFunction): string;
+    buildOrderByClause(clauses: OrderByClause[]): {
+        column: string;
+        order: 'asc' | 'desc';
+        null?: 'first' | 'last';
+    }[];
+    supportsFeature(feature: DatabaseFeature): boolean;
+    sanitizeIdentifier(identifier: string): string;
+}
+export declare enum DatabaseFeature {
+    WindowFunctions = "windowFunctions",
+    CTEs = "ctes",
+    RecursiveCTEs = "recursiveCTEs",
+    NullsOrdering = "nullsOrdering",
+    JsonOperations = "jsonOperations",
+    ArrayOperations = "arrayOperations"
+}
+//# sourceMappingURL=base.d.ts.map

package/dist/cjs/adapters/base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.d.ts","sourceRoot":"","sources":["../../../src/adapters/base.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9D,MAAM,WAAW,eAAe;IAC9B,mBAAmB,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM,CAAC;IAChD,kBAAkB,CAChB,OAAO,EAAE,aAAa,EAAE,GACvB;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAE,EAAE,CAAC;IACxE,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO,CAAC;IACnD,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM,CAAC;CAChD;AAED,oBAAY,eAAe;IACzB,eAAe,oBAAoB;IACnC,IAAI,SAAS;IACb,aAAa,kBAAkB;IAC/B,aAAa,kBAAkB;IAC/B,cAAc,mBAAmB;IACjC,eAAe,oBAAoB;CACpC"}

package/dist/cjs/adapters/base.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseFeature = void 0;
+var DatabaseFeature;
+(function (DatabaseFeature) {
+    DatabaseFeature["WindowFunctions"] = "windowFunctions";
+    DatabaseFeature["CTEs"] = "ctes";
+    DatabaseFeature["RecursiveCTEs"] = "recursiveCTEs";
+    DatabaseFeature["NullsOrdering"] = "nullsOrdering";
+    DatabaseFeature["JsonOperations"] = "jsonOperations";
+    DatabaseFeature["ArrayOperations"] = "arrayOperations";
+})(DatabaseFeature || (exports.DatabaseFeature = DatabaseFeature = {}));
+//# sourceMappingURL=base.js.map

package/dist/cjs/adapters/base.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"base.js","sourceRoot":"","sources":["../../../src/adapters/base.ts"],"names":[],"mappings":";;;AAWA,IAAY,eAOX;AAPD,WAAY,eAAe;IACzB,sDAAmC,CAAA;IACnC,gCAAa,CAAA;IACb,kDAA+B,CAAA;IAC/B,kDAA+B,CAAA;IAC/B,oDAAiC,CAAA;IACjC,sDAAmC,CAAA;AACrC,CAAC,EAPW,eAAe,+BAAf,eAAe,QAO1B"}

package/dist/cjs/adapters/index.d.ts

@@ -0,0 +1,6 @@
+import type { Kysely } from 'kysely';
+import type { DatabaseAdapter } from './base';
+export declare function getAdapter(db: Kysely<any>): DatabaseAdapter;
+export { DatabaseFeature } from './base';
+export type { DatabaseAdapter } from './base';
+//# sourceMappingURL=index.d.ts.map

package/dist/cjs/adapters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,QAAQ,CAAC;AAGrC,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAE9C,wBAAgB,UAAU,CAAC,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,GAAG,eAAe,CAgB3D;AAED,OAAO,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AACzC,YAAY,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC"}

package/dist/cjs/adapters/index.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DatabaseFeature = void 0;
+exports.getAdapter = getAdapter;
+const sqlite_1 = require("./sqlite");
+const postgres_1 = require("./postgres");
+function getAdapter(db) {
+    // Try to determine the adapter from the executor or provided config
+    // Kysely structure: db.getExecutor().adapter
+    // This is a heuristic based on Kysely internal class names or we can rely on passed config if we had it.
+    // Assuming standard Kysely adapters.
+    const adapterName = db.getExecutor().adapter.constructor.name;
+    if (adapterName.includes('Postgres')) {
+        return new postgres_1.PostgresAdapter();
+    }
+    else if (adapterName.includes('Sqlite') || adapterName.includes('Libsql')) {
+        return new sqlite_1.SQLiteAdapter();
+    }
+    // Default fallback or more checks
+    return new sqlite_1.SQLiteAdapter(); // Safest default for now? Or better throw?
+}
+var base_1 = require("./base");
+Object.defineProperty(exports, "DatabaseFeature", { enumerable: true, get: function () { return base_1.DatabaseFeature; } });
+//# sourceMappingURL=index.js.map

package/dist/cjs/adapters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/adapters/index.ts"],"names":[],"mappings":";;;AAKA,gCAgBC;AApBD,qCAAyC;AACzC,yCAA6C;AAG7C,SAAgB,UAAU,CAAC,EAAe;IACxC,oEAAoE;IACpE,6CAA6C;IAE7C,yGAAyG;IACzG,qCAAqC;IACrC,MAAM,WAAW,GAAG,EAAE,CAAC,WAAW,EAAE,CAAC,OAAO,CAAC,WAAW,CAAC,IAAI,CAAC;IAE9D,IAAI,WAAW,CAAC,QAAQ,CAAC,UAAU,CAAC,EAAE,CAAC;QACrC,OAAO,IAAI,0BAAe,EAAE,CAAC;IAC/B,CAAC;SAAM,IAAI,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,WAAW,CAAC,QAAQ,CAAC,QAAQ,CAAC,EAAE,CAAC;QAC5E,OAAO,IAAI,sBAAa,EAAE,CAAC;IAC7B,CAAC;IAED,kCAAkC;IAClC,OAAO,IAAI,sBAAa,EAAE,CAAC,CAAC,2CAA2C;AACzE,CAAC;AAED,+BAAyC;AAAhC,uGAAA,eAAe,OAAA"}

package/dist/cjs/adapters/postgres.d.ts

@@ -0,0 +1,13 @@
+import { type DatabaseAdapter, DatabaseFeature } from './base';
+import type { WindowFunction, OrderByClause } from '../sdk/server';
+export declare class PostgresAdapter implements DatabaseAdapter {
+    buildWindowFunction(wf: WindowFunction): string;
+    buildOrderByClause(clauses: OrderByClause[]): {
+        column: string;
+        order: 'asc' | 'desc';
+        null?: 'first' | 'last';
+    }[];
+    supportsFeature(feature: DatabaseFeature): boolean;
+    sanitizeIdentifier(identifier: string): string;
+}
+//# sourceMappingURL=postgres.d.ts.map

package/dist/cjs/adapters/postgres.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.d.ts","sourceRoot":"","sources":["../../../src/adapters/postgres.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,KAAK,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAEnE,qBAAa,eAAgB,YAAW,eAAe;IACrD,mBAAmB,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM;IAwB/C,kBAAkB,CAChB,OAAO,EAAE,aAAa,EAAE,GACvB;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAE,EAAE;IASvE,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO;IAYlD,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAI/C"}

package/dist/cjs/adapters/postgres.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PostgresAdapter = void 0;
+const base_1 = require("./base");
+class PostgresAdapter {
+    buildWindowFunction(wf) {
+        // PostgreSQL full window function support
+        const fnCall = wf.type === 'row_number'
+            ? 'ROW_NUMBER()'
+            : `${wf.type}(${wf.field || '*'})`;
+        let overClause = 'OVER (';
+        if (wf.partitionBy?.length) {
+            overClause += `PARTITION BY ${wf.partitionBy.join(',')}`;
+        }
+        if (wf.orderBy?.length) {
+            overClause += ` ORDER BY ${wf.orderBy
+                .map((ob) => `${ob.field} ${ob.direction || 'ASC'}`)
+                .join(',')}`;
+        }
+        if (wf.frameClause) {
+            overClause += ` ${wf.frameClause}`;
+        }
+        overClause += ')';
+        return `${fnCall} ${overClause} AS ${wf.alias}`;
+    }
+    buildOrderByClause(clauses) {
+        // PostgreSQL supports NULLS FIRST/LAST natively
+        return clauses.map(({ field, direction, nulls }) => ({
+            column: field,
+            order: direction || 'asc',
+            nulls: nulls,
+        }));
+    }
+    supportsFeature(feature) {
+        const supported = {
+            [base_1.DatabaseFeature.WindowFunctions]: true,
+            [base_1.DatabaseFeature.CTEs]: true,
+            [base_1.DatabaseFeature.RecursiveCTEs]: true,
+            [base_1.DatabaseFeature.NullsOrdering]: true,
+            [base_1.DatabaseFeature.JsonOperations]: true,
+            [base_1.DatabaseFeature.ArrayOperations]: true,
+        };
+        return supported[feature] || false;
+    }
+    sanitizeIdentifier(identifier) {
+        // PostgreSQL identifier sanitization
+        return `"${identifier.replace(/"/g, '""')}"`;
+    }
+}
+exports.PostgresAdapter = PostgresAdapter;
+//# sourceMappingURL=postgres.js.map

package/dist/cjs/adapters/postgres.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"postgres.js","sourceRoot":"","sources":["../../../src/adapters/postgres.ts"],"names":[],"mappings":";;;AAAA,iCAA+D;AAG/D,MAAa,eAAe;IAC1B,mBAAmB,CAAC,EAAkB;QACpC,0CAA0C;QAC1C,MAAM,MAAM,GACV,EAAE,CAAC,IAAI,KAAK,YAAY;YACtB,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,GAAG,EAAE,CAAC,IAAI,IAAI,EAAE,CAAC,KAAK,IAAI,GAAG,GAAG,CAAC;QAEvC,IAAI,UAAU,GAAG,QAAQ,CAAC;QAC1B,IAAI,EAAE,CAAC,WAAW,EAAE,MAAM,EAAE,CAAC;YAC3B,UAAU,IAAI,gBAAgB,EAAE,CAAC,WAAW,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QAC3D,CAAC;QACD,IAAI,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,CAAC;YACvB,UAAU,IAAI,aAAa,EAAE,CAAC,OAAO;iBAClC,GAAG,CAAC,CAAC,EAAE,EAAE,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,IAAI,EAAE,CAAC,SAAS,IAAI,KAAK,EAAE,CAAC;iBACnD,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC;QACjB,CAAC;QACD,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;YACnB,UAAU,IAAI,IAAI,EAAE,CAAC,WAAW,EAAE,CAAC;QACrC,CAAC;QACD,UAAU,IAAI,GAAG,CAAC;QAElB,OAAO,GAAG,MAAM,IAAI,UAAU,OAAO,EAAE,CAAC,KAAK,EAAE,CAAC;IAClD,CAAC;IAED,kBAAkB,CAChB,OAAwB;QAExB,gDAAgD;QAChD,OAAO,OAAO,CAAC,GAAG,CAAC,CAAC,EAAE,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,EAAE,EAAE,CAAC,CAAC;YACnD,MAAM,EAAE,KAAK;YACb,KAAK,EAAE,SAAS,IAAI,KAAK;YACzB,KAAK,EAAE,KAAK;SACb,CAAC,CAAC,CAAC;IACN,CAAC;IAED,eAAe,CAAC,OAAwB;QACtC,MAAM,SAAS,GAAG;YAChB,CAAC,sBAAe,CAAC,eAAe,CAAC,EAAE,IAAI;YACvC,CAAC,sBAAe,CAAC,IAAI,CAAC,EAAE,IAAI;YAC5B,CAAC,sBAAe,CAAC,aAAa,CAAC,EAAE,IAAI;YACrC,CAAC,sBAAe,CAAC,aAAa,CAAC,EAAE,IAAI;YACrC,CAAC,sBAAe,CAAC,cAAc,CAAC,EAAE,IAAI;YACtC,CAAC,sBAAe,CAAC,eAAe,CAAC,EAAE,IAAI;SACxC,CAAC;QACF,OAAO,SAAS,CAAC,OAAO,CAAC,IAAI,KAAK,CAAC;IACrC,CAAC;IAED,kBAAkB,CAAC,UAAkB;QACnC,qCAAqC;QACrC,OAAO,IAAI,UAAU,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,CAAC,GAAG,CAAC;IAC/C,CAAC;CACF;AApDD,0CAoDC"}

package/dist/cjs/adapters/sqlite.d.ts

@@ -0,0 +1,13 @@
+import { type DatabaseAdapter, DatabaseFeature } from './base';
+import { WindowFunction, OrderByClause } from '../sdk/server';
+export declare class SQLiteAdapter implements DatabaseAdapter {
+    buildWindowFunction(wf: WindowFunction): string;
+    buildOrderByClause(clauses: OrderByClause[]): {
+        column: string;
+        order: 'asc' | 'desc';
+        null?: 'first' | 'last';
+    }[];
+    supportsFeature(feature: DatabaseFeature): boolean;
+    sanitizeIdentifier(identifier: string): string;
+}
+//# sourceMappingURL=sqlite.d.ts.map

package/dist/cjs/adapters/sqlite.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sqlite.d.ts","sourceRoot":"","sources":["../../../src/adapters/sqlite.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAC;AAC/D,OAAO,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE9D,qBAAa,aAAc,YAAW,eAAe;IACnD,mBAAmB,CAAC,EAAE,EAAE,cAAc,GAAG,MAAM;IAqB/C,kBAAkB,CAChB,OAAO,EAAE,aAAa,EAAE,GACvB;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,KAAK,GAAG,MAAM,CAAC;QAAC,IAAI,CAAC,EAAE,OAAO,GAAG,MAAM,CAAA;KAAE,EAAE;IAQvE,eAAe,CAAC,OAAO,EAAE,eAAe,GAAG,OAAO;IAYlD,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,MAAM;CAI/C"}