@entity-access/entity-access 1.0.54 → 1.0.56

package/src/entity-query/EntityType.ts

@@ -3,7 +3,7 @@ import { IClassOf } from "../decorators/IClassOf.js";
 import { Query } from "../query/Query.js";
 import NameParser from "../decorators/parser/NameParser.js";
 import SchemaRegistry from "../decorators/SchemaRegistry.js";
-import { Expression, ExpressionAs, QuotedLiteral, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
+import { Expression, ExpressionAs, NumberLiteral, SelectStatement, TableLiteral } from "../query/ast/Expressions.js";
 import InstanceCache from "../common/cache/InstanceCache.js";
 import { IIndex } from "../decorators/IIndex.js";
 
@@ -37,10 +37,10 @@ export default class EntityType {
     public get fullyQualifiedName() {
         return this.schema
             ? TableLiteral.create({
-                schema: QuotedLiteral.create({literal: this.schema}) ,
-                name: QuotedLiteral.create({ literal: this.name })
+                schema: Expression.identifier(this.schema) ,
+                name: Expression.identifier(this.name)
             })
-            : QuotedLiteral.create({ literal: this.name });
+            : Expression.identifier(this.name);
     }
 
     private fieldMap: Map<string, IColumn> = new Map();
@@ -50,6 +50,16 @@ export default class EntityType {
     private selectAll: SelectStatement;
     private selectOne: SelectStatement;
 
+    constructor(original?: EntityType) {
+        if (!original) {
+            return;
+        }
+        this.typeClass = original.typeClass;
+        this.name = original.name;
+        this.schema = original.schema;
+        this.entityName = original.entityName;
+    }
+
     [addOrCreateColumnSymbol](name: string): IColumn {
         return this.fieldMap.get(name) ?? { name };
     }
@@ -86,7 +96,7 @@ export default class EntityType {
         return this.fieldMap.get(name);
     }
 
-    addRelation(relation: IEntityRelation) {
+    addRelation(relation: IEntityRelation, getInverseModel?: (t) => EntityType) {
         // we will also set fk to the corresponding column
         this.relations.push(relation);
         this.relationMap.set(relation.name, relation);
@@ -108,8 +118,12 @@ export default class EntityType {
             fkColumn.dataType = "BigInt";
         }
 
+        if (!getInverseModel) {
+            return relation;
+        }
+
         // let us set inverse relations...
-        const relatedType = SchemaRegistry.model(relation.relatedTypeClass);
+        const relatedType = getInverseModel(relation.relatedTypeClass);
         relation.relatedEntity = relatedType;
         const inverseRelation: IEntityRelation = {
             name: relation.relatedName,
@@ -137,12 +151,7 @@ export default class EntityType {
         }
         const source = this.fullyQualifiedName;
         const as = Expression.parameter(this.name[0] + "1");
-        const fields = this.columns.map((c) => c.name !== c.columnName
-            ? ExpressionAs.create({
-                expression: Expression.member(as, c.columnName),
-                alias: QuotedLiteral.create({ literal: c.name })
-            })
-            : Expression.member(as, c.columnName));
+        const fields = this.columns.map((c) => Expression.member(as, c.columnName));
         this.selectAll = SelectStatement.create({
             source,
             model: this,
@@ -159,7 +168,7 @@ export default class EntityType {
         const source = this.fullyQualifiedName;
         const as = Expression.parameter(this.name[0] + "1");
         const fields = [
-            Expression.identifier("1")
+            NumberLiteral.one
         ];
         this.selectOne = SelectStatement.create({
             source,
@@ -169,4 +178,16 @@ export default class EntityType {
         });
         return { ... this.selectOne };
     }
+
+    public map(row: any) {
+        const c = new this.typeClass();
+        for (const iterator of this.columns) {
+            const value = row[iterator.columnName];
+            if (value === void 0) {
+                continue;
+            }
+            c[iterator.name] = value;
+        }
+        return c;
+    }
 }

package/src/eternity/EternityStorage.ts

@@ -10,8 +10,8 @@ import WorkflowClock from "./WorkflowClock.js";
 @Table("Workflows")
 @Index({
     name: "IX_Workflows_Group",
-    columns: [{ name: (x) => x.group, descending: false }],
-    filter: (x) => x.group !== null
+    columns: [{ name: (x) => x.groupName, descending: false }],
+    filter: (x) => x.groupName !== null
 })
 @Index({
     name: "IX_Workflows_ETA",
@@ -30,7 +30,7 @@ export class WorkflowStorage {
     public name: string;
 
     @Column({ dataType: "Char", length: 200, nullable: true })
-    public group: string;
+    public groupName: string;
 
     @Column({ dataType: "Char"})
     public input: string;

package/src/migrations/Migrations.ts

@@ -1,3 +1,4 @@
+import { modelSymbol } from "../common/symbols/symbols.js";
 import type QueryCompiler from "../compiler/QueryCompiler.js";
 import { IIndex } from "../decorators/IIndex.js";
 import SchemaRegistry from "../decorators/SchemaRegistry.js";
@@ -10,8 +11,9 @@ export default abstract class Migrations {
     constructor(protected compiler: QueryCompiler) {}
 
     public async migrate(context: EntityContext) {
-        for (const iterator of context.model.entities.keys()) {
-            const type = SchemaRegistry.model(iterator);
+        const { model } = context;
+        for (const s of model.sources.values()) {
+            const type = s[modelSymbol] as EntityType;
             await this.migrateTable(context, type);
 
             for (const index of type.indexes) {
@@ -30,7 +32,7 @@ export default abstract class Migrations {
             // parse..
             const source = context.query(type.typeClass) as EntityQuery<any>;
             const { target , textQuery } = this.compiler.compileToSql(source, `(p) => ${index.filter}` as any);
-            index.filter = textQuery.join("").split( this.compiler.quotedLiteral(source.selectStatement.sourceParameter.name) + ".").join("");
+            index.filter = textQuery.join("").split( source.selectStatement.sourceParameter.name + ".").join("");
         }
 
         this.migrateIndex(context, index, type);

package/src/migrations/postgres/PostgresAutomaticMigrations.ts

@@ -28,7 +28,7 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
     async createIndexes(context: EntityContext, type: EntityType, fkColumns: IColumn[]) {
         for (const iterator of fkColumns) {
             const filter = iterator.nullable
-                ? `${ JSON.stringify(iterator.columnName)} IS NOT NULL`
+                ? `${iterator.columnName} IS NOT NULL`
                 : "";
             const indexDef: IIndex = {
                 name: `IX_${type.name}_${iterator.columnName}`,
@@ -42,15 +42,15 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
     async createColumns(driver: BaseDriver, type: EntityType, nonKeyColumns: IColumn[]) {
 
         const name = type.schema
-        ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
-        : JSON.stringify(type.name);
+        ? type.schema + "." + type.name
+        : type.name;
 
         if (nonKeyColumns.length > 1) {
             nonKeyColumns.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
         }
 
         for (const iterator of nonKeyColumns) {
-            const columnName = JSON.stringify(iterator.columnName);
+            const columnName = iterator.columnName;
             let def = `ALTER TABLE ${name} ADD COLUMN IF NOT EXISTS ${columnName} `;
             def += this.getColumnDefinition(iterator);
             if (iterator.nullable !== true) {
@@ -67,8 +67,8 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
     async createTable(driver: BaseDriver, type: EntityType, keys: IColumn[]) {
 
         const name = type.schema
-            ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
-            : JSON.stringify(type.name);
+            ? type.schema + "." + type.name
+            : type.name;
 
         if (keys.length > 1) {
             keys.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
@@ -77,29 +77,32 @@ export default class PostgresAutomaticMigrations extends PostgresMigrations {
         const fields = [];
 
         for (const iterator of keys) {
-            let def = JSON.stringify(iterator.columnName) + " ";
+            let def = iterator.columnName + " ";
             if (iterator.autoGenerate) {
-                def += iterator.dataType === "BigInt" ? "bigserial " : "serial ";
+                def += iterator.dataType === "BigInt" ? "bigint " : "int ";
+                def += " not null GENERATED BY DEFAULT AS IDENTITY\r\n\t";
             } else {
                 def += this.getColumnDefinition(iterator);
+                def += " not null \r\n\t";
             }
-            def += " not null primary key\r\n\t";
             fields.push(def);
         }
 
-        await driver.executeQuery(`CREATE TABLE IF NOT EXISTS ${name} (${fields.join(",")})`);
+        await driver.executeQuery(`CREATE TABLE IF NOT EXISTS ${name} (${fields.join(",")}
+        ,CONSTRAINT PK_${name} PRIMARY KEY (${keys.map((x) => x.columnName).join(",")})
+        )`);
 
     }
 
     async migrateIndex(context: EntityContext, index: IIndex, type: EntityType) {
         const driver = context.driver;
         const name = type.schema
-        ? JSON.stringify(type.schema) + "." + JSON.stringify(type.name)
-        : JSON.stringify(type.name);
-        const indexName =  JSON.stringify(index.name);
+        ? type.schema + "." + type.name
+        : type.name;
+        const indexName =  index.name;
         const columns = [];
         for (const column of index.columns) {
-            const columnName = JSON.stringify(column.name);
+            const columnName = column.name;
             columns.push(`${columnName} ${column.descending ? "DESC" : "ASC"}`);
         }
         let query = `CREATE ${index.unique ? "UNIQUE" : ""} INDEX IF NOT EXISTS ${indexName} ON ${name} ( ${columns.join(", ")})`;

package/src/migrations/sql-server/SqlServerAutomaticMigrations.ts

@@ -29,10 +29,10 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
     async createIndexes(context: EntityContext, type: EntityType, fkColumns: IColumn[]) {
         for (const iterator of fkColumns) {
             const filter = iterator.nullable
-                ? `${ SqlServerLiteral.quotedLiteral(iterator.columnName)} IS NOT NULL`
+                ? `${ iterator.columnName} IS NOT NULL`
                 : "";
             const indexDef: IIndex = {
-                name: `IX_${type.name}_${iterator.columnName}`,
+                name: `IX_${type.name}_${iterator.name}`,
                 columns: [{ name: iterator.columnName, descending: iterator.indexOrder !== "ascending"}],
                 filter
             };
@@ -43,15 +43,15 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
     async createColumns(driver: BaseDriver, type: EntityType, nonKeyColumns: IColumn[]) {
 
         const name = type.schema
-        ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
-        : SqlServerLiteral.quotedLiteral(type.name);
+        ? type.schema + "." + type.name
+        : type.name;
 
         if (nonKeyColumns.length > 1) {
             nonKeyColumns.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
         }
 
         for (const iterator of nonKeyColumns) {
-            const columnName = SqlServerLiteral.quotedLiteral(iterator.columnName);
+            const columnName = iterator.columnName;
             let def = `IF COL_LENGTH(${ SqlServerLiteral.escapeLiteral(name)}, ${ SqlServerLiteral.escapeLiteral(columnName)}) IS NULL ALTER TABLE ${name} ADD ${columnName} `;
             def += this.getColumnDefinition(iterator);
             if (iterator.nullable === true) {
@@ -70,8 +70,8 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
     async createTable(driver: BaseDriver, type: EntityType, keys: IColumn[]) {
 
         const name = type.schema
-            ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
-            : SqlServerLiteral.quotedLiteral(type.name);
+            ? type.schema + "." + type.name
+            : type.name;
 
         if (keys.length > 1) {
             keys.sort((a, b) => (a.order ?? 0) - (b.order ?? 0));
@@ -80,7 +80,7 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
         const fields = [];
 
         for (const iterator of keys) {
-            let def = SqlServerLiteral.quotedLiteral(iterator.columnName) + " ";
+            let def = iterator.columnName + " ";
             if (iterator.autoGenerate) {
                 def += this.getColumnDefinition(iterator) + " IDENTITY(1,1)";
             } else {
@@ -99,12 +99,12 @@ export default class SqlServerAutomaticMigrations extends SqlServerMigrations {
     async migrateIndex(context: EntityContext, index: IIndex, type: EntityType) {
         const driver = context.driver;
         const name = type.schema
-            ? SqlServerLiteral.quotedLiteral(type.schema) + "." + SqlServerLiteral.quotedLiteral(type.name)
-            : SqlServerLiteral.quotedLiteral(type.name);
-        const indexName =  SqlServerLiteral.quotedLiteral(index.name);
+            ? type.schema + "." + type.name
+            : type.name;
+        const indexName =  index.name;
         const columns = [];
         for (const column of index.columns) {
-            const columnName = SqlServerLiteral.quotedLiteral(column.name);
+            const columnName = column.name;
             columns.push(`${columnName} ${column.descending ? "DESC" : "ASC"}`);
         }
         let query = `IF NOT EXISTS(SELECT * FROM sys.indexes WHERE name = '${indexName}' AND object_id = OBJECT_ID('${name}'))

package/src/model/EntityContext.ts

@@ -56,6 +56,27 @@ export default class EntityContext {
         return query;
     }
 
+    filteredQuery<T>(type: IClassOf<T>, mode: "read" | "include" | "modify" | "delete", fail = false, parentType?, key?) {
+        const query = this.model.register(type).asQuery();
+        if (!this.verifyFilters) {
+            return query;
+        }
+        const events = this.eventsFor(type, fail);
+        if (events) {
+            switch(mode) {
+                case "read":
+                    return events.filter(query) ?? query;
+                case "include":
+                    return events.includeFilter(query, parentType, key) ?? query;
+                case "modify":
+                    return events.modify(query) ?? query;
+                case "delete":
+                    return events.delete(query) ?? query;
+            }
+        }
+        return query;
+    }
+
     public async saveChanges(signal?: AbortSignal) {
 
         if (this[isChanging]) {
@@ -160,7 +181,7 @@ export default class EntityContext {
 
     protected async saveChangesWithoutEvents(signal: AbortSignal) {
         return this.driver.runInTransaction(async () => {
-            const copy = [].concat(this.changeSet.entries);
+            const copy = [].concat(this.changeSet.entries) as ChangeEntry[];
             for (const iterator of copy) {
                 switch (iterator.status) {
                     case "inserted":

package/src/model/EntityModel.ts

@@ -1,27 +1,61 @@
 import type EntityContext from "./EntityContext.js";
 import { IClassOf } from "../decorators/IClassOf.js";
 import SchemaRegistry from "../decorators/SchemaRegistry.js";
-import EntityQuery from "./EntityQuery.js";
-import { Expression } from "@babel/types";
 import { EntitySource } from "./EntitySource.js";
+import { BaseDriver } from "../drivers/base/BaseDriver.js";
+import EntityType from "../entity-query/EntityType.js";
+import { IStringTransformer } from "../query/ast/IStringTransformer.js";
+import { IEntityRelation } from "../decorators/IColumn.js";
 
+const driverModelCache = Symbol("driverModelCache");
 
+const getOrCreateModel = (map: Map<any, EntityType>, type: IClassOf<any>, namingConvention: IStringTransformer) => {
+    let t = map.get(type);
+    if (t) {
+        return t;
+    }
+    const original = SchemaRegistry.model(type);
+    t = new EntityType(original);
+    map.set(type,  t);
+    for (const iterator of original.columns) {
+        const column = { ... iterator };
+        column.columnName = column.explicitName ? column.columnName : (namingConvention ? namingConvention(column.columnName) : column.columnName);
+        t.addColumn(column);
+        column.entityType = t;
+    }
+    for (const iterator of original.relations) {
+        if (iterator.isInverseRelation) {
+            continue;
+        }
+        const relation: IEntityRelation = { ... iterator, fkColumn: void 0, relatedEntity: void 0,type: t };
+        t.addRelation(relation, (tc) => getOrCreateModel(map, tc, namingConvention));
+    }
+    return t;
+};
 
 export default class EntityModel {
 
-    public entities: Map<IClassOf<any>, EntitySource> = new Map();
+    public sources: Map<IClassOf<any>, EntitySource> = new Map();
+
+    public types: Map<IClassOf<any>, EntityType> = new Map();
 
     constructor(private context: EntityContext) {
     }
 
     register<T>(type: IClassOf<T>) {
-        let source = this.entities.get(type);
+        let source = this.sources.get(type);
         if (!source) {
-            const model = SchemaRegistry.model(type);
-            source = new EntitySource(model, this.context);
-            this.entities.set(type, source);
+            const cache = (this.context.driver[driverModelCache] ??= new Map());
+            const entityType = getOrCreateModel(cache, type, this.context.driver.compiler.namingConvention);
+            this.types.set(type, entityType);
+            source = new EntitySource(entityType, this.context);
+            this.sources.set(type, source);
         }
         return source as EntitySource<T>;
     }
 
+    getEntityType<T>(type: IClassOf<T>): EntityType{
+        return this.types.get(type);
+    }
+
 }

package/src/model/EntityQuery.ts

@@ -2,7 +2,7 @@ import Logger from "../common/Logger.js";
 import { DisposableScope } from "../common/usingAsync.js";
 import { ServiceProvider } from "../di/di.js";
 import EntityType from "../entity-query/EntityType.js";
-import { CallExpression, Expression, ExpressionAs, Identifier, OrderByExpression, QuotedLiteral, SelectStatement } from "../query/ast/Expressions.js";
+import { CallExpression, Expression, ExpressionAs, Identifier, OrderByExpression, SelectStatement } from "../query/ast/Expressions.js";
 import { QueryExpander } from "../query/expander/QueryExpander.js";
 import EntityContext from "./EntityContext.js";
 import { IOrderedEntityQuery, IEntityQuery } from "./IFilterWithParameter.js";
@@ -95,9 +95,9 @@ export default class EntityQuery<T = any>
             scope.register(reader);
             for await (const iterator of reader.next(10, signal)) {
                 if (type) {
-                    Object.setPrototypeOf(iterator, type.typeClass.prototype);
+                    const item = type?.map(iterator) ?? iterator;
                     // set identity...
-                    const entry = this.context.changeSet.getEntry(iterator, iterator);
+                    const entry = this.context.changeSet.getEntry(item, item);
                     relationMapper.fix(entry);
                     yield entry.entity;
                     continue;
@@ -118,8 +118,8 @@ export default class EntityQuery<T = any>
         const reader = await this.context.driver.executeReader(query, signal);
         try {
             for await (const iterator of reader.next(10, signal)) {
-                Object.setPrototypeOf(iterator, select.model.typeClass.prototype);
-                const entry = this.context.changeSet.getEntry(iterator, iterator);
+                const item = select.model?.map(iterator) ?? iterator;
+                const entry = this.context.changeSet.getEntry(item, item);
                 relationMapper.fix(entry);
             }
         } catch (error) {
@@ -183,7 +183,7 @@ export default class EntityQuery<T = any>
                     callee: Identifier.create({ value: "COUNT"}),
                     arguments: [ Identifier.create({ value: "*"})]
                 }),
-                alias: QuotedLiteral.create({ literal: "count" })
+                alias: Expression.identifier("c1")
             })
         ] };
 
@@ -194,7 +194,7 @@ export default class EntityQuery<T = any>
 
         try {
             for await (const iterator of reader.next()) {
-                return iterator.count as number;
+                return iterator.c1 as number;
             }
         } finally {
             await reader.dispose();

package/src/model/SourceExpression.ts

@@ -1,6 +1,6 @@
 import { modelSymbol } from "../common/symbols/symbols.js";
 import EntityType from "../entity-query/EntityType.js";
-import { BinaryExpression, Expression, ExpressionAs, Identifier, JoinExpression, MemberExpression, ParameterExpression, QuotedLiteral, SelectStatement } from "../query/ast/Expressions.js";
+import { Expression, JoinExpression, ParameterExpression, SelectStatement } from "../query/ast/Expressions.js";
 import { ITextQueryFragment, QueryParameter } from "../query/ast/IStringTransformer.js";
 import EntityContext from "./EntityContext.js";
 
@@ -64,7 +64,7 @@ export class SourceExpression {
             as: source.alias,
             joinType: column.nullable ? "LEFT" : "INNER",
             model,
-            source: QuotedLiteral.create({ literal: model.name }),
+            source: Expression.identifier(model.name),
             where: Expression.logicalAnd(
                 Expression.member(
                     this.alias,
@@ -121,9 +121,8 @@ export class SourceExpression {
 
     prepareNames([property , ... others]: string[]): ITextQueryFragment {
         const p = this.model.getProperty(property);
-        const quotedLiteral = this.context.driver.compiler.quotedLiteral;
         if (others.length === 0) {
-            return `${ QueryParameter.create(() => this.alias.name, quotedLiteral)}.${quotedLiteral(p.field.columnName)}`;
+            return `${ QueryParameter.create(() => this.alias.name)}.${p.field.columnName}`;
         }
 
         // this must be a navigation...

package/src/model/changes/ChangeEntry.ts

@@ -89,9 +89,9 @@ export default class ChangeEntry<T = any> implements IChanges {
         this.detectDependencies();
 
         for (const iterator of columns) {
-            const oldValue = original[iterator.columnName];
+            const oldValue = original[iterator.name];
             const newValue = entity[iterator.name];
-            if (entity[iterator.name] !== original[iterator.columnName]) {
+            if (entity[iterator.name] !== original[iterator.name]) {
                 let modifiedEntry = this.modified.get(iterator);
                 if (!modifiedEntry) {
                     modifiedEntry = { column: iterator, oldValue, newValue };

package/src/model/changes/ChangeSet.ts

@@ -52,7 +52,7 @@ export default class ChangeSet {
         if (c === Object) {
             throw new EntityAccessError("Entity type not set");
         }
-        const type = SchemaRegistry.model(c);
+        const type = this.context.model.getEntityType(c);
         const jsonKey = IdentityService.getIdentity(entity);
         if (jsonKey) {
             const existing = this.identityMap.get(jsonKey);

package/src/model/verification/VerificationSession.ts

@@ -3,8 +3,7 @@ import Logger from "../../common/Logger.js";
 import { TypeInfo } from "../../common/TypeInfo.js";
 import { IEntityRelation } from "../../decorators/IColumn.js";
 import { ServiceProvider } from "../../di/di.js";
-import EntityType from "../../entity-query/EntityType.js";
-import { ConditionalExpression, Constant, ExistsExpression, Expression, Identifier, ParameterExpression, QuotedLiteral, SelectStatement, TemplateLiteral, ValuesStatement } from "../../query/ast/Expressions.js";
+import { ConditionalExpression, ExistsExpression, Expression, NumberLiteral, ParameterExpression, SelectStatement, ValuesStatement } from "../../query/ast/Expressions.js";
 import EntityContext from "../EntityContext.js";
 import EntityQuery from "../EntityQuery.js";
 import ChangeEntry from "../changes/ChangeEntry.js";
@@ -106,7 +105,7 @@ export default class VerificationSession {
         const eq = query as EntityQuery;
         for (const [key, value] of keys) {
             const test = Expression.equal(
-                Expression.member(eq.selectStatement.sourceParameter, Expression.quotedLiteral(key)),
+                Expression.member(eq.selectStatement.sourceParameter, Expression.identifier(key)),
                 Expression.constant(value)
             );
             compare = compare
@@ -127,10 +126,10 @@ export default class VerificationSession {
         this.select.sourceParameter = ParameterExpression.create({ name: "x"});
         const source = ValuesStatement.create({
             values: [
-                [Identifier.create({ value: "1"})]
+                [NumberLiteral.one]
             ],
-            as: QuotedLiteral.create({ literal: "a"}),
-            fields: [QuotedLiteral.create({ literal: "a"})]
+            as: Expression.identifier("a"),
+            fields: [Expression.identifier("a")]
         });
         this.select.source = source;
         const compiler = this.context.driver.compiler;
@@ -151,7 +150,7 @@ export default class VerificationSession {
     addError(query: EntityQuery, compare: Expression, error: string) {
         const select = { ... query.selectStatement};
         select.fields = [
-            Expression.identifier("1")
+            NumberLiteral.one
         ];
 
         const where = select.where

package/src/query/ast/DebugStringVisitor.ts

@@ -1,4 +1,4 @@
-import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, QuotedLiteral, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
+import { ArrowFunctionExpression, BigIntLiteral, BinaryExpression, BooleanLiteral, CallExpression, CoalesceExpression, ConditionalExpression, Constant, DeleteStatement, ExistsExpression, Expression, ExpressionAs, Identifier, InsertStatement, JoinExpression, MemberExpression, NewObjectExpression, NotExits, NullExpression, NumberLiteral, OrderByExpression, ParameterExpression, ReturnUpdated, SelectStatement, StringLiteral, TableLiteral, TemplateElement, TemplateLiteral, UnionAllStatement, UpdateStatement, ValuesStatement } from "./Expressions.js";
 import Visitor from "./Visitor.js";
 
 const isBinary = (type) => /^(BinaryExpression|CoalesceExpression)$/.test(type);
@@ -89,10 +89,6 @@ export default class DebugStringVisitor extends Visitor<string> {
         return e.name;
     }
 
-    visitQuotedLiteral(e: QuotedLiteral): string {
-        return `"${e.literal}"`;
-    }
-
     visitStringLiteral(e: StringLiteral): string {
         return `'${e.value}'`;
     }