remult 0.22.12 → 0.22.13-exp.0

package/SseSubscriptionServer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { GenericResponse } from './server/index';
 import type { Remult } from './src/context';
 import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
@@ -19,7 +18,7 @@ export declare class clientConnection {
     close(): void;
     closed: boolean;
     write(eventData: string, eventType?: string): void;
-    connectionId: any;
+    connectionId: string;
     constructor(response: GenericResponse & ResponseRequiredForSSE);
     sendLiveMessage(): void;
 }

package/assign.js

@@ -1,9 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.assign = void 0;
+exports.assign = assign;
 function assign(item, valuesToSet) {
     if (valuesToSet)
         Object.assign(item, valuesToSet);
     return item;
 }
-exports.assign = assign;

package/esm/SseSubscriptionServer.d.ts

@@ -1,4 +1,3 @@
-/// <reference types="node" />
 import type { GenericResponse } from './server/index';
 import type { Remult } from './src/context';
 import type { SubscriptionServer } from './src/live-query/SubscriptionServer';
@@ -19,7 +18,7 @@ export declare class clientConnection {
     close(): void;
     closed: boolean;
     write(eventData: string, eventType?: string): void;
-    connectionId: any;
+    connectionId: string;
     constructor(response: GenericResponse & ResponseRequiredForSSE);
     sendLiveMessage(): void;
 }

package/esm/internals.js

@@ -1,5 +1,7 @@
-export { getRelationInfo } from './src/remult3/relationInfoMember';
-export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation';
-export { getEntitySettings } from './src/remult3/getEntityRef';
-export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces';
-export { actionInfo } from './src/server-action-info';
+import { remultStatic } from './src/remult-static.js';
+export { getRelationInfo, getRelationFieldInfo, } from './src/remult3/relationInfoMember.js';
+export { decorateColumnSettings, controllerRefImpl, getControllerRef, } from './src/remult3/RepositoryImplementation.js';
+export { getEntitySettings } from './src/remult3/getEntityRef.js';
+export { __updateEntityBasedOnWhere } from './src/filter/filter-interfaces.js';
+export const actionInfo = remultStatic.actionInfo;
+export { flags } from './src/remult3/remult3.js';

package/esm/migrations/compare-migration-snapshots.js

@@ -0,0 +1,61 @@
+import { repo } from '../index.js';
+import { dbNamesOf, shouldCreateEntity, shouldNotCreateField, } from '../src/filter/filter-consumer-bridge-to-sql-request.js';
+export async function compareMigrationSnapshot({ entities, snapshot, migrationBuilder, reporter, }) {
+    snapshot = JSON.parse(JSON.stringify(snapshot));
+    let processedEntities = new Set();
+    for (const entity of entities) {
+        const meta = repo(entity).metadata;
+        const e = await dbNamesOf(meta, (x) => x);
+        processedEntities.add(e.$entityName);
+        if (shouldCreateEntity(meta, e)) {
+            let entitySnapshot = snapshot.entities[e.$entityName];
+            let createColumns = true;
+            if (!entitySnapshot) {
+                createColumns = false;
+                reporter('create table ' + e.$entityName);
+                await migrationBuilder.createTable(meta);
+                entitySnapshot = snapshot.entities[e.$entityName] = {
+                    key: meta.key,
+                    className: meta.entityType.name,
+                    columns: {},
+                };
+            }
+            const processedColumns = new Set();
+            for (const field of meta.fields) {
+                if (!shouldNotCreateField(field, e)) {
+                    const columnDbName = e.$dbNameOf(field);
+                    processedColumns.add(columnDbName);
+                    const column = entitySnapshot.columns[columnDbName];
+                    if (!column) {
+                        if (createColumns) {
+                            reporter('add column ' + e.$entityName + '.' + columnDbName);
+                            await migrationBuilder.addColumn(meta, field);
+                        }
+                        entitySnapshot.columns[columnDbName] = { key: field.key };
+                    }
+                }
+            }
+            for (const columnDbName of Object.keys(entitySnapshot.columns)) {
+                if (!processedColumns.has(columnDbName)) {
+                    reporter('remove column ' + e.$entityName + '.' + columnDbName);
+                    await migrationBuilder.removeColumn(e.$entityName, columnDbName);
+                    delete entitySnapshot.columns[columnDbName];
+                }
+            }
+        }
+    }
+    for (const entityDbName of Object.keys(snapshot.entities)) {
+        if (!processedEntities.has(entityDbName)) {
+            reporter('remove table ' + entityDbName);
+            await migrationBuilder.removeTable(entityDbName);
+            delete snapshot.entities[entityDbName];
+        }
+    }
+    return snapshot;
+}
+export function emptySnapshot() {
+    return {
+        version: 1,
+        entities: {},
+    };
+}

package/esm/migrations/generate-migrations.js

@@ -0,0 +1,68 @@
+import path from 'path';
+import fs from 'fs';
+import { compareMigrationSnapshot, emptySnapshot, } from './compare-migration-snapshots.js';
+import { updateMigrationsFile } from './update-migrations-ts-file.js';
+import { DefaultMigrationBuilder, } from './migration-types.js';
+import { isOfType } from '../src/isOfType.js';
+import { initDataProviderOrJson } from '../server/initDataProviderOrJson.js';
+/**
+ * Generates migration scripts based on changes in entities.
+ *
+ * @param options - Configuration options for generating migrations.
+ * @param options.entities - An array of entity classes whose changes will be included in the migration.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsFolder - (Optional) The path to the folder where migration scripts will be stored. Default is 'src/migrations'.
+ * @param options.snapshotFile - (Optional) The path to the file where the snapshot of the last known state will be stored. Default is 'migrations-snapshot.json' in the `migrationsFolder`.
+ * @param options.migrationsTSFile - (Optional) The path to the TypeScript file where the generated migrations will be written. Default is 'migrations.ts' in the `migrationsFolder`.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after generating migrations. Default is false.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+export async function generateMigrations(options) {
+    const migrationDir = options.migrationsFolder || path.join(process.cwd(), 'src/migrations');
+    const snapshotFileName = options.snapshotFile || path.join(migrationDir, 'migrations-snapshot.json');
+    const migrationsTSFilename = options.migrationsTSFile || path.join(migrationDir, 'migrations.ts');
+    const dataProvider = await initDataProviderOrJson(options.dataProvider);
+    for (const p of [snapshotFileName, migrationsTSFilename]) {
+        if (!fs.existsSync(path.dirname(p))) {
+            fs.mkdirSync(path.dirname(p), { recursive: true });
+        }
+    }
+    let snapshot = emptySnapshot();
+    if (fs.existsSync(snapshotFileName)) {
+        snapshot = JSON.parse(fs.readFileSync(snapshotFileName).toString());
+    }
+    let hasSql = false;
+    let steps = [];
+    const code = {
+        //https://marketplace.visualstudio.com/items?itemName=qufiwefefwoyn.inline-sql-syntax
+        addSql: (sql) => {
+            steps.push('await sql(`--sql\n' + sql + '`)');
+            hasSql = true;
+        },
+        addTypescriptCode: (code) => steps.push(code),
+        addComment: (comment) => steps.push(comment.indexOf('\n') >= 0 ? `/*${comment}*/` : `// ${comment}`),
+    };
+    let migrationBuilder = new DefaultMigrationBuilder(code);
+    if (isOfType(dataProvider, 'provideMigrationBuilder')) {
+        migrationBuilder = new DefaultMigrationBuilder(code, dataProvider.provideMigrationBuilder(code));
+    }
+    let reporter = (what) => console.log('[generateMigrations] ' + what);
+    snapshot = await compareMigrationSnapshot({
+        entities: options.entities,
+        snapshot,
+        reporter,
+        migrationBuilder,
+    });
+    if (steps.length)
+        await updateMigrationsFile(migrationsTSFilename, [
+            `async (${hasSql ? '{sql}' : ''})=>{\n${steps.join('\n')}\n}`,
+        ]);
+    else {
+        reporter('No changes detected');
+    }
+    fs.writeFileSync(snapshotFileName, JSON.stringify(snapshot, null, 2));
+    if (options.endConnection && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
+    return steps.length > 0;
+}

package/esm/migrations/index.js

@@ -0,0 +1,2 @@
+export { generateMigrations } from './generate-migrations.js';
+export { migrate } from './migrate.js';

package/esm/migrations/migrate.js

@@ -0,0 +1,85 @@
+import { Entity, IdEntity, Fields, remult, Remult, describeClass, } from '../index.js';
+import { initDataProviderOrJson } from '../server/initDataProviderOrJson.js';
+import { doTransaction } from '../src/context.js';
+import { cast, isOfType } from '../src/isOfType.js';
+/**
+ * Applies migration scripts to update the database schema.
+ *
+ * @param options - Configuration options for applying migrations.
+ * @param options.migrations - An object containing the migration scripts, each keyed by a unique identifier.
+ * @param options.dataProvider - The data provider instance or a function returning a promise of the data provider.
+ * @param options.migrationsTable - (Optional) The name of the table that tracks applied migrations. Default is '__remult_migrations_version'.
+ * @param options.endConnection - (Optional) Determines whether to close the database connection after applying migrations. Default is false.
+ * @param options.beforeMigration - (Optional) A callback function that is called before each migration is applied. Receives an object with the migration index.
+ * @param options.afterMigration - (Optional) A callback function that is called after each migration is applied. Receives an object with the migration index and the duration of the migration.
+ * @see [Migrations](https://remult.dev/docs/migrations.html)
+ */
+export async function migrate(options) {
+    let migrationTableName = options.migrationsTable || '__remult_migrations_version';
+    const dataProvider = await initDataProviderOrJson(options.dataProvider);
+    const prev = remult.dataProvider;
+    remult.dataProvider = dataProvider;
+    try {
+        class VersionInfo extends IdEntity {
+            version = -1;
+        }
+        describeClass(VersionInfo, Entity(migrationTableName), {
+            version: Fields.integer(),
+        });
+        const steps = Object.entries(options.migrations).sort(([a], [b]) => parseInt(a) - parseInt(b));
+        if (dataProvider.ensureSchema) {
+            await dataProvider.ensureSchema([
+                new Remult(dataProvider).repo(VersionInfo).metadata,
+            ]);
+        }
+        await doTransaction(remult, async (dp) => {
+            const repo = new Remult(dataProvider).repo(VersionInfo, dp);
+            let v = await repo.findFirst();
+            if (!v) {
+                v = repo.create();
+                v.version = -1;
+            }
+            for (const [stepText, action] of steps) {
+                const step = parseInt(stepText);
+                if (step < 0)
+                    throw new Error('Migration step number must be a non-negative integer');
+                if (v.version >= step)
+                    continue;
+                if (options.beforeMigration) {
+                    await options.beforeMigration({ index: step });
+                }
+                const startTime = Date.now();
+                console.info('Executing migration step ' + step);
+                console.time('Completed migration step ' + step);
+                try {
+                    const utils = {
+                        sql: async (sql) => {
+                            return await cast(dp, 'execute').execute(sql);
+                        },
+                    };
+                    await action(utils);
+                    if (options.afterMigration) {
+                        await options.afterMigration({
+                            index: step,
+                            duration: Date.now() - startTime,
+                        });
+                    }
+                    console.timeEnd('Completed migration step ' + step);
+                }
+                catch (err) {
+                    console.error('Failed to execute migration step ' + step);
+                    console.error(err);
+                    throw err;
+                }
+                v.version = step;
+                await v.save();
+            }
+        });
+    }
+    finally {
+        remult.dataProvider = prev;
+    }
+    if (options.endConnection && isOfType(dataProvider, 'end')) {
+        await dataProvider.end();
+    }
+}

package/esm/migrations/migration-types.js

@@ -0,0 +1,36 @@
+export class DefaultMigrationBuilder {
+    code;
+    wrapped;
+    constructor(code, wrapped) {
+        this.code = code;
+        this.wrapped = wrapped;
+    }
+    async createTable(meta) {
+        if (this.wrapped?.createTable) {
+            await this.wrapped.createTable(meta);
+        }
+        else
+            this.code.addComment('TODO: implement create table ' + meta.dbName);
+    }
+    async addColumn(meta, field) {
+        if (this.wrapped?.addColumn) {
+            await this.wrapped.addColumn(meta, field);
+        }
+        else
+            this.code.addComment('TODO: implement add column ' + meta.dbName + '.' + field.dbName);
+    }
+    async removeTable(entityDbName) {
+        if (this.wrapped?.removeTable) {
+            await this.wrapped.removeTable(entityDbName);
+        }
+        else
+            this.code.addComment('TODO: implement remove table ' + entityDbName);
+    }
+    async removeColumn(entityName, columnDbName) {
+        if (this.wrapped?.removeColumn) {
+            await this.wrapped.removeColumn(entityName, columnDbName);
+        }
+        else
+            this.code.addComment('TODO: implement remove column ' + entityName + '.' + columnDbName);
+    }
+}

package/esm/migrations/update-migrations-ts-file.js

@@ -0,0 +1,115 @@
+// consider replacing with https://www.npmjs.com/package/ts-morph
+export async function updateMigrationsFile(filePath, steps) {
+    let ts = await import('typescript');
+    //@ts-ignore
+    if (ts.default)
+        ts = ts.default;
+    const fs = await import('fs');
+    let maxStep = -1;
+    function buildSteps() {
+        return steps.map((step) => ts.factory.createPropertyAssignment(ts.factory.createIdentifier((++maxStep).toString()), ts.factory.createIdentifier(step)));
+    }
+    if (!fs.existsSync(filePath)) {
+        fs.writeFileSync(filePath, '');
+    }
+    const importPath = 'remult/migrations';
+    const importName = 'Migrations';
+    // Load the file
+    const sourceFile = ts.createSourceFile(filePath, fs.readFileSync(filePath).toString(), ts.ScriptTarget.Latest, true);
+    let migrationsExportFound = false;
+    // Find the "migrations" named export and add the new member
+    let updatedSourceFile = ts.transform(sourceFile, [
+        (context) => {
+            return (node) => {
+                const visitor = (node) => {
+                    if (ts.isVariableStatement(node) &&
+                        node.declarationList.declarations.length > 0) {
+                        const declaration = node.declarationList.declarations[0];
+                        if (ts.isIdentifier(declaration.name) &&
+                            declaration.name.text === 'migrations' &&
+                            declaration.initializer &&
+                            ts.isObjectLiteralExpression(declaration.initializer)) {
+                            migrationsExportFound = true;
+                            declaration.initializer.properties.forEach((property) => {
+                                if (ts.isPropertyAssignment(property)) {
+                                    if (ts.isNumericLiteral(property.name)) {
+                                        const step = parseInt(property.name.text);
+                                        if (step > maxStep) {
+                                            maxStep = step;
+                                        }
+                                    }
+                                }
+                            });
+                            let steps = buildSteps();
+                            // Found the "migrations" array
+                            // Update the initializer with the new steps
+                            const updatedInitializer = ts.factory.updateObjectLiteralExpression(declaration.initializer, [...declaration.initializer.properties, ...steps]);
+                            // Update the declaration with the new initializer
+                            const updatedDeclaration = ts.factory.updateVariableDeclaration(declaration, declaration.name, undefined, declaration.type, // Preserve the original type annotation if present
+                            updatedInitializer);
+                            return ts.factory.updateVariableStatement(node, node.modifiers, ts.factory.updateVariableDeclarationList(node.declarationList, [
+                                updatedDeclaration,
+                            ]));
+                        }
+                    }
+                    return ts.visitEachChild(node, visitor, context);
+                };
+                return ts.visitNode(node, visitor);
+            };
+        },
+    ]).transformed[0];
+    if (!migrationsExportFound) {
+        let importFound = false;
+        // Check if the import statement already exists
+        sourceFile.statements.forEach((statement) => {
+            if (ts.isImportDeclaration(statement) &&
+                ts.isStringLiteral(statement.moduleSpecifier) &&
+                statement.moduleSpecifier.text === `${importPath}`) {
+                statement.importClause?.namedBindings?.forEachChild((namedBinding) => {
+                    if (ts.isImportSpecifier(namedBinding) &&
+                        namedBinding.name.text === importName) {
+                        importFound = true;
+                    }
+                });
+            }
+        });
+        // If the import statement doesn't exist, create it
+        if (!importFound) {
+            updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, [
+                ts.factory.createExpressionStatement(ts.factory.createIdentifier(`import type { ${importName} } from '${importPath}'`)),
+                ...updatedSourceFile.statements,
+            ]);
+        }
+        // Create a new export for migrations if it doesn't exist
+        const newMigrationsExport = ts.factory.createVariableStatement([ts.factory.createModifier(ts.SyntaxKind.ExportKeyword)], ts.factory.createVariableDeclarationList([
+            ts.factory.createVariableDeclaration('migrations', undefined, // You can add a type annotation here if needed
+            ts.factory.createTypeReferenceNode(importName, undefined), ts.factory.createObjectLiteralExpression(buildSteps(), false)),
+        ], ts.NodeFlags.Const));
+        // Add the new export to the end of the file
+        updatedSourceFile = ts.factory.updateSourceFile(updatedSourceFile, [
+            ...updatedSourceFile.statements,
+            newMigrationsExport,
+        ]);
+    }
+    let code = ts.createPrinter().printFile(updatedSourceFile);
+    try {
+        let prettier;
+        try {
+            prettier = await import('prettier' + '');
+        }
+        catch (err) {
+            console.warn('error importing prettier,for better formatting run `npm i -D prettier`. Writing raw code to file.');
+        }
+        if (prettier) {
+            let options = await prettier.resolveConfig();
+            code = await prettier.format(code, {
+                ...options,
+                parser: 'typescript',
+            });
+        }
+    }
+    catch (err) {
+        console.log('error formatting code, writing raw code to file.');
+    }
+    fs.writeFileSync(filePath, code);
+}

package/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}

package/esm/remult-better-sqlite3.js

@@ -0,0 +1,47 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+export class BetterSqlite3DataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BetterSqlite3Command(db), async () => { db.close(); });
+    }
+}
+class BetterSqlite3Command {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.prepare(sql);
+        if (s.reader) {
+            return new BetterSqlite3SqlResult(s.all(this.values));
+        }
+        else {
+            const result = s.run(this.values);
+            return new BetterSqlite3SqlResult([]);
+        }
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key.substring(1)] = (val);
+        return key;
+    }
+}
+export class BetterSqlite3SqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-bun-sqlite.js

@@ -0,0 +1,41 @@
+import { SqliteCoreDataProvider } from "./remult-sqlite-core.js";
+export class BunSqliteDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new BunSqliteCommand(db), async () => { db.close(); });
+    }
+}
+class BunSqliteCommand {
+    db;
+    values = {};
+    i = 0;
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        const s = this.db.query(sql);
+        return new BunSqliteSqlResult(s.all(this.values));
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        if (val instanceof Date)
+            val = val.valueOf();
+        if (typeof val === "boolean")
+            val = val ? 1 : 0;
+        const key = ':' + (this.i++);
+        this.values[key] = (val);
+        return key;
+    }
+}
+class BunSqliteSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}

package/esm/remult-duckdb.js

@@ -0,0 +1,116 @@
+import { SqliteCoreDataProvider } from './remult-sqlite-core.js';
+import { ValueConverters, dbNamesOf, } from './index.js';
+import { shouldNotCreateField } from './src/filter/filter-consumer-bridge-to-sql-request.js';
+import { isAutoIncrement } from './src/remult3/RepositoryImplementation.js';
+export class DuckDBDataProvider extends SqliteCoreDataProvider {
+    constructor(db) {
+        super(() => new DuckDBCommand(db), async () => (await db).close(), false, true);
+    }
+    wrapIdentifier(name) {
+        return `"${name}"`;
+    }
+    async getCreateTableSql(entity) {
+        let result = '';
+        let e = await dbNamesOf(entity, this.wrapIdentifier);
+        let sql = '';
+        for (const x of entity.fields) {
+            if (!shouldNotCreateField(x, e) || isAutoIncrement(x)) {
+                if (result.length != 0)
+                    result += ',';
+                result += '\r\n  ';
+                if (isAutoIncrement(x)) {
+                    const sequenceName = `${entity.dbName}_${x.dbName}_seq`;
+                    sql += `create sequence if not exists "${sequenceName}";\r\n`;
+                    result += `${e.$dbNameOf(x)} integer default nextval('${sequenceName}')`;
+                }
+                else {
+                    result += this.addColumnSqlSyntax(x, e.$dbNameOf(x), false);
+                }
+            }
+        }
+        result += `,\r\n   primary key (${entity.idMetadata.fields
+            .map((f) => e.$dbNameOf(f))
+            .join(',')})`;
+        sql +=
+            'create table if not exists ' + e.$entityName + ' (' + result + '\r\n)';
+        return sql;
+    }
+    addColumnSqlSyntax(x, dbName, isAlterColumn) {
+        let result = dbName;
+        var allowNull = x.allowNull;
+        if (allowNull && isAlterColumn) {
+            allowNull = false;
+            console.log('DuckDB does not support altering columns to allow null on existing tables');
+        }
+        if (x.valueType == Number) {
+            if (!x.valueConverter.fieldTypeInDb)
+                result += ' numeric' + (allowNull ? '' : ' default 0 not null');
+            else
+                result +=
+                    ' ' +
+                        x.valueConverter.fieldTypeInDb +
+                        (x.allowNull || isAlterColumn ? '' : ' default 0 not null');
+        }
+        else if (x.valueType == Date) {
+            if (!x.valueConverter.fieldTypeInDb)
+                if (x.valueConverter == ValueConverters.DateOnly)
+                    result += ' date';
+                else
+                    result += ' timestamp';
+            else
+                result += ' ' + x.valueConverter.fieldTypeInDb;
+        }
+        else if (x.valueType == Boolean)
+            result +=
+                ' boolean' +
+                    (x.allowNull || isAlterColumn ? '' : ' default false not null');
+        else if (x.valueConverter.fieldTypeInDb) {
+            result += ' ' + x.valueConverter.fieldTypeInDb;
+            if (!(x.allowNull || isAlterColumn) &&
+                x.valueConverter.fieldTypeInDb == 'integer') {
+                result += ' default 0 not null';
+            }
+        }
+        else
+            result +=
+                ' varchar' +
+                    (x.allowNull || isAlterColumn ? '' : " default '' not null");
+        return result;
+    }
+}
+class DuckDBCommand {
+    db;
+    values = [];
+    constructor(db) {
+        this.db = db;
+    }
+    async execute(sql) {
+        return new Promise((resolve, error) => {
+            this.db.all(sql, ...this.values, (err, rows) => {
+                if (err)
+                    error(err);
+                else
+                    resolve(new DuckDBSqlResult(rows));
+            });
+        });
+    }
+    addParameterAndReturnSqlToken(val) {
+        return this.param(val);
+    }
+    param(val) {
+        const key = '?';
+        this.values.push(val);
+        return key;
+    }
+}
+class DuckDBSqlResult {
+    result;
+    constructor(result) {
+        this.result = result;
+        this.rows = result;
+    }
+    rows;
+    getColumnKeyInResultForIndexInSelect(index) {
+        return Object.keys(this.result[0])[index];
+    }
+}