@sqb/connect 4.20.6 → 4.21.0

package/{types/client → client}/cursor-stream.d.ts

@@ -1,5 +1,5 @@
 import { Readable } from 'stream';
-import { Cursor } from './cursor.js';
+import type { Cursor } from './cursor.js';
 export interface CursorStreamOptions {
     objectMode?: boolean;
     limit?: number;

package/{types/client → client}/cursor.d.ts

@@ -1,8 +1,8 @@
-import { Adapter } from './adapter.js';
+import type { Adapter } from './adapter.js';
 import { CursorStream, CursorStreamOptions } from './cursor-stream.js';
-import { FieldInfoMap } from './field-info-map.js';
-import { SqbConnection } from './sqb-connection.js';
-import { ObjectRow, QueryRequest } from './types.js';
+import type { FieldInfoMap } from './field-info-map.js';
+import type { SqbConnection } from './sqb-connection.js';
+import type { ObjectRow, QueryRequest } from './types.js';
 interface CursorEvents {
     close: () => void;
     error: (error: unknown) => void;

package/{types/client → client}/sqb-connection.d.ts

@@ -1,9 +1,9 @@
 import { classes } from '@sqb/builder';
-import { Type } from 'ts-gems';
+import type { Type } from 'ts-gems';
 import { Repository } from '../orm/repository.class.js';
-import { Adapter } from './adapter.js';
-import { SqbClient } from './sqb-client.js';
-import { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types.js';
+import type { Adapter } from './adapter.js';
+import type { SqbClient } from './sqb-client.js';
+import type { ConnectionOptions, QueryExecuteOptions, QueryRequest } from './types.js';
 interface SqbConnectionEvents {
     close: () => void;
     execute: (request: QueryRequest) => void;

package/{esm/orm → orm}/commands/command.helper.js

@@ -1,7 +1,6 @@
 import { And, Eq, Exists, Field, InnerJoin, isCompOperator, isLogicalOperator, LeftOuterJoin, op, OperatorType, Raw, Select, } from '@sqb/builder';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { isAssociationField, isColumnField, isEmbeddedField, } from '../util/orm.helper.js';
+import { isAssociationField, isColumnField, isEmbeddedField, resolveEntityForEmbeddedField, } from '../util/orm.helper.js';
 export async function joinAssociationGetFirst(joinInfos, association, parentAlias, innerJoin) {
     const joins = await joinAssociation(joinInfos, association, parentAlias, innerJoin);
     return joins[0];
@@ -107,7 +106,7 @@ export async function prepareFilter(entityDef, filter, trgOp, tableAlias = 'T')
                         if (isColumnField(col))
                             throw new Error(`Invalid column (${item._left}) defined in filter`);
                         if (isEmbeddedField(col)) {
-                            _curEntity = await EmbeddedFieldMetadata.resolveType(col);
+                            _curEntity = await resolveEntityForEmbeddedField(col);
                             _curPrefix = _curPrefix + (col.fieldNamePrefix || '');
                             _curSuffix = (col.fieldNameSuffix || '') + _curSuffix;
                             continue;

package/{types/orm → orm}/commands/count.command.d.ts

@@ -1,6 +1,6 @@
-import { SqbConnection } from '../../client/sqb-connection.js';
+import type { SqbConnection } from '../../client/sqb-connection.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { Repository } from '../repository.class.js';
+import type { Repository } from '../repository.class.js';
 export type CountCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

package/{types/orm → orm}/commands/create.command.d.ts

@@ -1,4 +1,4 @@
-import { SqbConnection } from '../../client/sqb-connection.js';
+import type { SqbConnection } from '../../client/sqb-connection.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
 export type CreateCommandArgs = {
     entity: EntityMetadata;

package/{esm/orm → orm}/commands/create.command.js

@@ -1,8 +1,6 @@
 import { Insert, Param } from '@sqb/builder';
-import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+import { checkEnumValue, isColumnField, isEmbeddedField, resolveEntityForEmbeddedField, } from '../util/orm.helper.js';
 export class CreateCommand {
     // istanbul ignore next
     constructor() {
@@ -68,7 +66,7 @@ export class CreateCommand {
                     }
                     continue;
                 }
-                ColumnFieldMetadata.checkEnumValue(col, v);
+                checkEnumValue(col, v);
                 const fieldName = prefix + col.fieldName + suffix;
                 const k = ('I$_' + fieldName).substring(0, 30);
                 ctx.queryValues[fieldName] = Param({
@@ -80,7 +78,7 @@ export class CreateCommand {
                 ctx.colCount++;
             }
             else if (v != null && isEmbeddedField(col)) {
-                const type = await EmbeddedFieldMetadata.resolveType(col);
+                const type = await resolveEntityForEmbeddedField(col);
                 await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
             }
         }

package/{types/orm → orm}/commands/delete.command.d.ts

@@ -1,6 +1,6 @@
-import { SqbConnection } from '../../client/sqb-connection.js';
+import type { SqbConnection } from '../../client/sqb-connection.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { Repository } from '../repository.class.js';
+import type { Repository } from '../repository.class.js';
 export type DestroyCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

package/{types/orm → orm}/commands/find.command.d.ts

@@ -1,7 +1,7 @@
-import { SqbConnection } from '../../client/sqb-connection.js';
+import type { SqbConnection } from '../../client/sqb-connection.js';
 import { AssociationNode } from '../model/association-node.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { Repository } from '../repository.class.js';
+import type { Repository } from '../repository.class.js';
 import { FieldsProjection } from '../util/parse-fields-projection.js';
 import { RowConverter } from './row-converter.js';
 export type FindCommandArgs = {

package/{esm/orm → orm}/commands/find.command.js

@@ -1,8 +1,7 @@
 import { And, In, Param, Select } from '@sqb/builder';
 import { AssociationNode } from '../model/association-node.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { isAssociationField, isColumnField, isEmbeddedField, } from '../util/orm.helper.js';
+import { isAssociationField, isColumnField, isEmbeddedField, resolveEntityForEmbeddedField, } from '../util/orm.helper.js';
 import { parseFieldsProjection, } from '../util/parse-fields-projection.js';
 import { joinAssociationGetLast, prepareFilter, } from './command.helper.js';
 import { RowConverter } from './row-converter.js';
@@ -107,7 +106,7 @@ export class FindCommand {
                 continue;
             }
             if (isEmbeddedField(col)) {
-                const typ = await EmbeddedFieldMetadata.resolveType(col);
+                const typ = await resolveEntityForEmbeddedField(col);
                 const subConverter = converter.addObjectProperty({
                     name: col.name,
                     type: typ.ctor,
@@ -205,7 +204,7 @@ export class FindCommand {
                 while (a.length > 1) {
                     const col = EntityMetadata.getField(_entityDef, a.shift() || '');
                     if (isEmbeddedField(col)) {
-                        _entityDef = await EmbeddedFieldMetadata.resolveType(col);
+                        _entityDef = await resolveEntityForEmbeddedField(col);
                         if (col.fieldNamePrefix)
                             prefix += col.fieldNamePrefix;
                         if (col.fieldNameSuffix)

package/{types/orm → orm}/commands/row-converter.d.ts

@@ -1,7 +1,7 @@
 import { DataType } from '@sqb/builder';
 import { Type } from 'ts-gems';
 import type { FieldInfoMap } from '../../client/field-info-map.js';
-import { SqbConnection } from '../../client/sqb-connection.js';
+import type { SqbConnection } from '../../client/sqb-connection.js';
 import { ColumnTransformFunction } from '../orm.type.js';
 import type { Repository } from '../repository.class.js';
 import type { FindCommand } from './find.command.js';

package/{types/orm → orm}/commands/update.command.d.ts

@@ -1,6 +1,6 @@
-import { SqbConnection } from '../../client/sqb-connection.js';
+import type { SqbConnection } from '../../client/sqb-connection.js';
 import { EntityMetadata } from '../model/entity-metadata.js';
-import { Repository } from '../repository.class.js';
+import type { Repository } from '../repository.class.js';
 export type UpdateCommandArgs = {
     entity: EntityMetadata;
     connection: SqbConnection;

package/{esm/orm → orm}/commands/update.command.js

@@ -1,7 +1,5 @@
 import { And, Param, Update } from '@sqb/builder';
-import { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
-import { isColumnField, isEmbeddedField } from '../util/orm.helper.js';
+import { checkEnumValue, isColumnField, isEmbeddedField, resolveEntityForEmbeddedField, } from '../util/orm.helper.js';
 import { prepareFilter } from './command.helper.js';
 export class UpdateCommand {
     // istanbul ignore next
@@ -59,7 +57,7 @@ export class UpdateCommand {
                     throw new Error(`${entity.name}.${col.name} is required and can't be null`);
                 if (v === undefined)
                     continue;
-                ColumnFieldMetadata.checkEnumValue(col, v);
+                checkEnumValue(col, v);
                 const fieldName = prefix + col.fieldName + suffix;
                 const k = ('I$_' + fieldName).substring(0, 30);
                 ctx.queryValues[fieldName] = Param({
@@ -71,7 +69,7 @@ export class UpdateCommand {
                 ctx.colCount++;
             }
             else if (v != null && isEmbeddedField(col)) {
-                const type = await EmbeddedFieldMetadata.resolveType(col);
+                const type = await resolveEntityForEmbeddedField(col);
                 await this._prepareParams(ctx, type, v, col.fieldNamePrefix, col.fieldNameSuffix);
             }
         }

package/{types/orm → orm}/model/association-field-metadata.d.ts

@@ -1,12 +1,7 @@
 import { AssociationNode } from './association-node.js';
-import { EntityMetadata } from './entity-metadata.js';
 import { FieldMetadata } from './field-metadata.js';
 export type AssociationFieldOptions = Partial<Omit<AssociationFieldMetadata, 'entity' | 'name' | 'kind' | 'association'>>;
 export interface AssociationFieldMetadata extends FieldMetadata {
     readonly kind: 'association';
     readonly association: AssociationNode;
 }
-export declare namespace AssociationFieldMetadata {
-    function create(entity: EntityMetadata, name: string, association: AssociationNode, options?: AssociationFieldOptions): AssociationFieldMetadata;
-    function assign(target: AssociationFieldMetadata, options: AssociationFieldOptions): void;
-}

package/{types/orm → orm}/model/association.d.ts

@@ -1,6 +1,6 @@
-import { AssociationSettings, TypeThunk } from '../orm.type.js';
-import { ColumnFieldMetadata } from './column-field-metadata.js';
-import { EntityMetadata } from './entity-metadata.js';
+import type { AssociationSettings, TypeThunk } from '../orm.type.js';
+import type { ColumnFieldMetadata } from './column-field-metadata.js';
+import type { EntityMetadata } from './entity-metadata.js';
 export declare class Association {
     private _resolved?;
     private _source?;

package/{esm/orm → orm}/model/association.js

@@ -1,6 +1,5 @@
 import { camelCase } from 'putil-varhelpers';
 import { resolveEntityMeta } from '../util/orm.helper.js';
-import { EntityMetadata } from './entity-metadata.js';
 export class Association {
     _resolved;
     _source; // cached value
@@ -59,6 +58,7 @@ export class Association {
         return this.many;
     }
     async _resolveKeys() {
+        const { EntityMetadata } = await import('../model/entity-metadata.js');
         if (this._resolved)
             return;
         const source = await this.resolveSource();

package/{types/orm → orm}/model/column-field-metadata.d.ts

@@ -1,6 +1,5 @@
 import { DataType } from '@sqb/builder';
 import type { ColumnAutoGenerationStrategy, ColumnTransformFunction, DefaultValueGetter, EnumValue, FieldValue } from '../orm.type.js';
-import type { EntityMetadata } from './entity-metadata.js';
 import { FieldMetadata } from './field-metadata.js';
 export type ColumnFieldOptions = Partial<Omit<ColumnFieldMetadata, 'entity' | 'name' | 'kind'>>;
 export interface ColumnFieldMetadata extends FieldMetadata {
@@ -58,18 +57,13 @@ export interface ColumnFieldMetadata extends FieldMetadata {
      */
     notNull?: boolean;
     /**
-     * Indicates if column value is used in update queries
+     * Indicates if the column value is used in update queries
      */
     noUpdate?: boolean;
     /**
-     * Indicates if column value is used in insert queries
+     * Indicates if the column value is used in insert queries
      */
     noInsert?: boolean;
     parse?: ColumnTransformFunction;
     serialize?: ColumnTransformFunction;
 }
-export declare namespace ColumnFieldMetadata {
-    function create(entity: EntityMetadata, name: string, options?: ColumnFieldOptions): ColumnFieldMetadata;
-    function assign(target: ColumnFieldMetadata, options: ColumnFieldOptions): void;
-    function checkEnumValue(col: ColumnFieldMetadata, v: FieldValue): void;
-}

package/{types/orm → orm}/model/embedded-field-metadata.d.ts

@@ -9,6 +9,5 @@ export interface EmbeddedFieldMetadata extends FieldMetadata {
     fieldNameSuffix?: string;
 }
 export declare namespace EmbeddedFieldMetadata {
-    function create(entity: EntityMetadata, name: string, type: TypeThunk, options?: EmbeddedFieldOptions): EmbeddedFieldMetadata;
     function resolveType(meta: EmbeddedFieldMetadata): Promise<EntityMetadata>;
 }

package/{esm/orm → orm}/model/embedded-field-metadata.js

@@ -1,20 +1,6 @@
 import { resolveEntityMeta } from '../util/orm.helper.js';
 export var EmbeddedFieldMetadata;
 (function (EmbeddedFieldMetadata) {
-    function create(entity, name, type, options) {
-        const result = {
-            kind: 'object',
-            entity,
-            name,
-            type,
-        };
-        if (options?.fieldNamePrefix)
-            result.fieldNamePrefix = options.fieldNamePrefix;
-        if (options?.fieldNameSuffix)
-            result.fieldNameSuffix = options.fieldNameSuffix;
-        return result;
-    }
-    EmbeddedFieldMetadata.create = create;
     async function resolveType(meta) {
         const typ = await resolveEntityMeta(meta.type);
         if (typ)

package/{types/orm → orm}/model/entity-metadata.d.ts

@@ -1,10 +1,10 @@
 import { Maybe, Type } from 'ts-gems';
 import { Ctor, TypeThunk } from '../orm.type.js';
 import { Association } from './association.js';
-import { AssociationFieldMetadata, AssociationFieldOptions } from './association-field-metadata.js';
+import type { AssociationFieldMetadata, AssociationFieldOptions } from './association-field-metadata.js';
 import { AssociationNode } from './association-node.js';
-import { ColumnFieldMetadata, ColumnFieldOptions } from './column-field-metadata.js';
-import { EmbeddedFieldMetadata, EmbeddedFieldOptions } from './embedded-field-metadata.js';
+import type { ColumnFieldMetadata, ColumnFieldOptions } from './column-field-metadata.js';
+import type { EmbeddedFieldMetadata, EmbeddedFieldOptions } from './embedded-field-metadata.js';
 import { IndexMetadata } from './index-metadata.js';
 export type AnyFieldMetadata = ColumnFieldMetadata | EmbeddedFieldMetadata | AssociationFieldMetadata;
 export type EntityOptions = Partial<Pick<EntityMetadata, 'name' | 'schema' | 'comment' | 'tableName'>>;

package/{esm/orm → orm}/model/entity-metadata.js

@@ -2,9 +2,6 @@ import { DataType } from '@sqb/builder';
 import { ENTITY_METADATA_KEY } from '../orm.const.js';
 import { isAssociationField, isColumnField, isEmbeddedField, } from '../util/orm.helper.js';
 import { Association } from './association.js';
-import { AssociationFieldMetadata, } from './association-field-metadata.js';
-import { ColumnFieldMetadata, } from './column-field-metadata.js';
-import { EmbeddedFieldMetadata, } from './embedded-field-metadata.js';
 export var EntityMetadata;
 (function (EntityMetadata) {
     function define(ctor) {
@@ -233,7 +230,13 @@ export var EntityMetadata;
                     options.dataType = DataType.VARCHAR;
             }
         }
-        prop = ColumnFieldMetadata.create(entity, name, options);
+        prop = {
+            fieldName: name,
+            ...options,
+            kind: 'column',
+            entity,
+            name,
+        };
         entity.fields[name.toLowerCase()] = prop;
         return prop;
     }
@@ -243,14 +246,26 @@ export var EntityMetadata;
         let prop = EntityMetadata.getField(entity, name);
         if (isEmbeddedField(prop))
             options = { ...prop, ...options };
-        prop = EmbeddedFieldMetadata.create(entity, name, type, options);
+        prop = {
+            ...options,
+            kind: 'object',
+            entity,
+            name,
+            type,
+        };
         entity.fields[name.toLowerCase()] = prop;
         return prop;
     }
     EntityMetadata.defineEmbeddedField = defineEmbeddedField;
     function defineAssociationField(entity, propertyKey, association, options) {
         delete entity._fieldNames;
-        const prop = AssociationFieldMetadata.create(entity, propertyKey, association, options);
+        const prop = {
+            ...options,
+            kind: 'association',
+            entity,
+            name: propertyKey,
+            association,
+        };
         let l = association;
         let i = 1;
         while (l) {

package/orm/model/index-metadata.js

@@ -0,0 +1 @@
+export {};

package/orm/orm.type.js

@@ -0,0 +1 @@
+export {};

package/{types/orm → orm}/repository.class.d.ts

@@ -1,8 +1,8 @@
 import { LogicalOperator } from '@sqb/builder';
 import { PartialDTO, PatchDTO, RequiredSome, StrictOmit, Type } from 'ts-gems';
 import { FieldInfoMap } from '../client/field-info-map.js';
-import { SqbClient } from '../client/sqb-client.js';
-import { SqbConnection } from '../client/sqb-connection.js';
+import type { SqbClient } from '../client/sqb-client.js';
+import type { SqbConnection } from '../client/sqb-connection.js';
 import { QueryRequest, TransactionFunction } from '../client/types.js';
 import { EntityMetadata } from './model/entity-metadata.js';
 interface Projection {

package/{esm/orm → orm}/repository.class.js

@@ -1,5 +1,4 @@
 import { AsyncEventEmitter, TypedEventEmitterClass } from 'strict-typed-events';
-import { SqbConnection } from '../client/sqb-connection.js';
 import { CountCommand } from './commands/count.command.js';
 import { CreateCommand } from './commands/create.command.js';
 import { DeleteCommand } from './commands/delete.command.js';
@@ -151,6 +150,7 @@ export class Repository extends TypedEventEmitterClass(AsyncEventEmitter) {
     }
     async _execute(fn, opts) {
         let connection = opts?.connection;
+        const { SqbConnection } = await import('../client/sqb-connection.js');
         if (!connection && this._executor instanceof SqbConnection)
             connection = this._executor;
         if (connection) {

package/{types/orm → orm}/util/orm.helper.d.ts

@@ -1,9 +1,9 @@
 import { Type } from 'ts-gems';
-import { AssociationFieldMetadata } from '../model/association-field-metadata.js';
+import type { AssociationFieldMetadata } from '../model/association-field-metadata.js';
 import type { ColumnFieldMetadata } from '../model/column-field-metadata.js';
-import { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
+import type { EmbeddedFieldMetadata } from '../model/embedded-field-metadata.js';
 import type { EntityMetadata } from '../model/entity-metadata.js';
-import type { TypeThunk } from '../orm.type.js';
+import type { FieldValue, TypeThunk } from '../orm.type.js';
 export declare function isClass(fn: any): fn is Type;
 export declare function isEntityClass(fn: any): fn is Type;
 export declare function isColumnField(f: any): f is ColumnFieldMetadata;
@@ -11,3 +11,5 @@ export declare const isEmbeddedField: (f: any) => f is EmbeddedFieldMetadata;
 export declare const isAssociationField: (f: any) => f is AssociationFieldMetadata;
 export declare function resolveEntity(ctorThunk: TypeThunk): Promise<Type | undefined>;
 export declare function resolveEntityMeta(ctorThunk: TypeThunk): Promise<EntityMetadata | undefined>;
+export declare function resolveEntityForEmbeddedField(meta: EmbeddedFieldMetadata): Promise<EntityMetadata>;
+export declare function checkEnumValue(col: ColumnFieldMetadata, v: FieldValue): void;

package/{esm/orm → orm}/util/orm.helper.js

@@ -22,3 +22,17 @@ export async function resolveEntityMeta(ctorThunk) {
     const ctor = await resolveEntity(ctorThunk);
     return ctor && Reflect.getMetadata(ENTITY_METADATA_KEY, ctor);
 }
+export async function resolveEntityForEmbeddedField(meta) {
+    const typ = await resolveEntityMeta(meta.type);
+    if (typ) {
+        return typ;
+    }
+    throw new Error(`Can't resolve type of ${meta.entity.name}.${meta.name}`);
+}
+export function checkEnumValue(col, v) {
+    if (v === undefined || !col.enum || (v == null && !col.notNull))
+        return;
+    const enumKeys = Array.isArray(col.enum) ? col.enum : Object.keys(col.enum);
+    if (!enumKeys.includes(v))
+        throw new Error(`${col.entity.name}.${col.name} value must be one of (${enumKeys})`);
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@sqb/connect",
   "description": "Multi-dialect database connection framework written with TypeScript",
-  "version": "4.20.6",
+  "version": "4.21.0",
   "author": "Panates",
   "license": "Apache-2.0",
   "dependencies": {
     "@jsopen/objects": "^2.0.2",
     "debug": "^4.4.3",
     "doublylinked": "^2.5.6",
-    "fast-tokenizer": "^1.7.0",
+    "fast-tokenizer": "^1.8.0",
     "lightning-pool": "^4.12.0",
     "lodash": "^4.17.21",
     "power-tasks": "^1.11.1",
@@ -21,27 +21,22 @@
     "tslib": "^2.8.1"
   },
   "peerDependencies": {
-    "@sqb/builder": "^4.20.6",
+    "@sqb/builder": "^4.21.0",
     "reflect-metadata": "^0.2.2"
   },
   "type": "module",
+  "module": "./index.js",
+  "types": "./index.d.ts",
   "exports": {
     ".": {
-      "import": {
-        "types": "./types/index.d.ts",
-        "default": "./esm/index.js"
-      },
-      "require": {
-        "types": "./types/index.d.cts",
-        "default": "./cjs/index.js"
-      },
-      "default": "./esm/index.js"
+      "types": "./index.d.ts",
+      "default": "./index.js"
     },
     "./package.json": "./package.json"
   },
-  "main": "./cjs/index.js",
-  "module": "./esm/index.js",
-  "types": "./types/index.d.ts",
+  "engines": {
+    "node": ">=20.0"
+  },
   "contributors": [
     "Eray Hanoglu <e.hanoglu@panates.com>",
     "Ilker Gurelli <i.gurelli@panates.com>"
@@ -51,17 +46,6 @@
     "url": "https://github.com/panates/sqb.git",
     "directory": "packages/connect"
   },
-  "engines": {
-    "node": ">=18.0"
-  },
-  "files": [
-    "bin/",
-    "cjs/",
-    "esm/",
-    "types/",
-    "LICENSE",
-    "README.md"
-  ],
   "keywords": [
     "sqb",
     "rdbms",

package/cjs/client/adapter.js

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

package/cjs/client/cursor-stream.js

@@ -1,104 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.CursorStream = void 0;
-const tslib_1 = require("tslib");
-const debug_1 = tslib_1.__importDefault(require("debug"));
-const stream_1 = require("stream");
-const inspect = Symbol.for('nodejs.util.inspect.custom');
-const debug = (0, debug_1.default)('sqb:cursorstream');
-class CursorStream extends stream_1.Readable {
-    _cursor;
-    _objectMode;
-    _limit;
-    _rowNum = -1;
-    _eof = false;
-    constructor(cursor, options) {
-        super(options);
-        this._cursor = cursor;
-        this._objectMode = options?.objectMode;
-        this._limit = options?.limit || Number.MAX_SAFE_INTEGER;
-        this.on('end', () => {
-            this.close().catch(() => false);
-        });
-        cursor.once('close', () => this.emit('close'));
-        cursor.on('error', err => this.emit('error', err));
-    }
-    /**
-     * Returns if stream is closed.
-     */
-    get isClosed() {
-        return this._cursor.isClosed;
-    }
-    /**
-     * Closes stream and releases the cursor
-     */
-    close() {
-        this.pause();
-        this.unpipe();
-        return this._cursor.close();
-    }
-    toString() {
-        return '[object ' + Object.getPrototypeOf(this).constructor.name + ']';
-    }
-    [inspect]() {
-        return this.toString();
-    }
-    _read() {
-        if (this._rowNum >= this._limit) {
-            this.pause();
-            this.unpipe();
-            this.emit('end');
-            return;
-        }
-        this._cursor
-            .next()
-            .then(row => {
-            if (this._eof)
-                return this.push(null);
-            let buf = '';
-            if (this._rowNum < 0) {
-                this._rowNum = 0;
-                if (!this._objectMode)
-                    buf += '[';
-            }
-            if (!row) {
-                this._eof = true;
-                if (!this._objectMode) {
-                    buf += ']';
-                    this.push(buf);
-                }
-                else
-                    this.push(null);
-                return;
-            }
-            this._rowNum++;
-            if (this._objectMode)
-                this.push(row);
-            else {
-                if (this._rowNum > 1)
-                    buf += ',';
-                this.push(buf + JSON.stringify(row));
-            }
-        })
-            .catch(err => {
-            /* istanbul ignore next */
-            if (typeof this.destroy == 'function')
-                this.destroy(err);
-            else
-                this.emit('error', err);
-            this.close().catch(() => 0);
-        });
-    }
-    emit(event, ...args) {
-        try {
-            if (event === 'error' && !this.listenerCount('error'))
-                return false;
-            return super.emit(event, ...args);
-        }
-        catch (ignored) {
-            debug('emit-error', ignored);
-            return false;
-        }
-    }
-}
-exports.CursorStream = CursorStream;