sasat 0.19.8 → 0.19.11

package/lib/db/connectors_v2/intefaces.d.ts

@@ -0,0 +1,22 @@
+export declare type QueryResponse = Array<{
+    [key: string]: string;
+}>;
+export interface CommandResponse {
+    insertId: number;
+    affectedRows: number;
+    changedRows: number;
+}
+export declare type SQLValueType = string | number | boolean | null;
+export interface SQLExecutor {
+    query(sql: string, values: SQLValueType[]): Promise<QueryResponse>;
+    command(sql: string, values: SQLValueType[]): Promise<CommandResponse>;
+}
+export interface SQLTransaction extends SQLExecutor {
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+}
+export interface DBClient extends SQLExecutor {
+    released(): boolean;
+    transaction(): Promise<SQLTransaction>;
+    release(): Promise<void>;
+}

package/lib/db/connectors_v2/intefaces.js

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

package/lib/db/connectors_v2/mysql_v2/client.d.ts

@@ -0,0 +1,14 @@
+import * as mysql from 'mysql2/promise';
+import { CommandResponse, DBClient, QueryResponse, SQLTransaction, SQLValueType } from '../intefaces.js';
+export declare class MysqlClient implements DBClient {
+    readonly connectionOption?: Partial<mysql.ConnectionOptions> | undefined;
+    private readonly pool;
+    private _released;
+    constructor(connectionOption?: Partial<mysql.ConnectionOptions> | undefined, poolOption?: Partial<mysql.PoolOptions>);
+    transaction(): Promise<SQLTransaction>;
+    release(): Promise<void>;
+    protected execute(sql: string, values: SQLValueType[]): Promise<QueryResponse | CommandResponse>;
+    command(sql: string, values: SQLValueType[]): Promise<CommandResponse>;
+    query(sql: string, values: SQLValueType[]): Promise<QueryResponse>;
+    released(): boolean;
+}

package/lib/db/connectors_v2/mysql_v2/client.js

@@ -0,0 +1,39 @@
+import * as mysql from 'mysql2/promise';
+import { config } from '../../../config/config.js';
+import { MySqlTransaction } from './transaction.js';
+const defaultConfig = { ...config().db, dateStrings: true };
+export class MysqlClient {
+    constructor(connectionOption, poolOption) {
+        this.connectionOption = connectionOption;
+        this._released = false;
+        this.pool = mysql.createPool({
+            ...defaultConfig,
+            ...connectionOption,
+            ...poolOption,
+        });
+    }
+    async transaction() {
+        const connection = await mysql.createConnection({
+            ...defaultConfig,
+            ...this.connectionOption,
+        });
+        await connection.beginTransaction();
+        return new MySqlTransaction(connection);
+    }
+    async release() {
+        await this.pool.end();
+        this._released = true;
+    }
+    execute(sql, values) {
+        return this.pool.execute(sql, values);
+    }
+    command(sql, values) {
+        return this.execute(sql, values);
+    }
+    query(sql, values) {
+        return this.execute(sql, values);
+    }
+    released() {
+        return this._released;
+    }
+}

package/lib/db/connectors_v2/mysql_v2/transaction.d.ts

@@ -0,0 +1,11 @@
+import * as mysql from 'mysql2/promise';
+import { CommandResponse, QueryResponse, SQLTransaction, SQLValueType } from '../intefaces.js';
+export declare class MySqlTransaction implements SQLTransaction {
+    private connection;
+    constructor(connection: mysql.Connection);
+    query(sql: string, values: SQLValueType[]): Promise<QueryResponse>;
+    command(sql: string, values: SQLValueType[]): Promise<CommandResponse>;
+    commit(): Promise<void>;
+    rollback(): Promise<void>;
+    protected execute(sql: string, values: SQLValueType[]): Promise<QueryResponse | CommandResponse>;
+}

package/lib/db/connectors_v2/mysql_v2/transaction.js

@@ -0,0 +1,24 @@
+export class MySqlTransaction {
+    constructor(connection) {
+        this.connection = connection;
+    }
+    query(sql, values) {
+        return this.execute(sql, values);
+    }
+    command(sql, values) {
+        return this.execute(sql, values);
+    }
+    async commit() {
+        await this.connection.commit();
+        await this.connection.end();
+        return;
+    }
+    async rollback() {
+        await this.connection.rollback();
+        await this.connection.end();
+        return;
+    }
+    execute(sql, values) {
+        return this.connection.execute(sql, values);
+    }
+}

package/lib/db/sql/createTable/createTableParser.js

@@ -3,7 +3,6 @@ import { camelize } from '../../../util/stringUtil.js';
 import { defaultColumnOption, } from '../../../migration/serialized/serializedColumn.js';
 import { getDefaultGqlOption } from '../../../migration/data/GQLOption.js';
 import { columnTypeToGqlPrimitive } from '../../../generatorv2/scripts/columnToGqlType.js';
-import { GqlPrimitive } from '../../../generatorv2/scripts/gqlTypes.js';
 const splitArray = (array, callback) => {
     const indexes = [];
     array.forEach((it, i) => {
@@ -94,8 +93,8 @@ export class CreateTableParser {
             if (next.kind === 'NULL')
                 return undefined;
             if (next.kind === TokenKind.Number ||
-                gqlType === GqlPrimitive.Float ||
-                gqlType === GqlPrimitive.Int)
+                gqlType === 'Float' ||
+                gqlType === 'Int')
                 return +next.value;
             if (next.kind === TokenKind.String)
                 return next.value;

package/lib/generatorv2/codegen/gql/generateTypeDefs.js

@@ -64,7 +64,7 @@ const makeUpdateInput = (node) => {
 };
 const makeQueryTypeDef = (entity, query) => {
     const args = getArgs(query, entity);
-    return tsg.propertyAssign(query.type === 'primary' ? entity.primaryQueryName() : query.name, typeFieldDefinitionToTsg({
+    return tsg.propertyAssign(query.type === 'primary' ? entity.name.lowerCase() : query.name, typeFieldDefinitionToTsg({
         return: GQLString.type({
             typeName: entity.name.name,
             entity: true,

package/lib/generatorv2/codegen/ts/generateUserDefinedCondition.d.ts

@@ -1,2 +1,2 @@
 import { RootNode } from '../../nodes/rootNode.js';
-export declare const generateUserDefinedCondition: (root: RootNode, content: string) => string;
+export declare const generateUserDefinedCondition: (root: RootNode, content: string) => string | null;

package/lib/generatorv2/codegen/ts/generateUserDefinedCondition.js

@@ -6,7 +6,10 @@ const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
 const isImported = (sourceFile, type, paths) => {
     const importDeclarations = sourceFile.statements.filter(it => it.kind === SyntaxKind.ImportDeclaration);
     return importDeclarations.some(it => {
-        if (!paths.includes(it.moduleSpecifier.getText(sourceFile)))
+        if (!paths.some(path => {
+            const text = it.moduleSpecifier.getText(sourceFile);
+            return `'${path}'` === text || `"${path}"` === text;
+        }))
             return false;
         const binding = it.importClause?.namedBindings;
         if (binding?.kind !== SyntaxKind.NamedImports)
@@ -17,17 +20,6 @@ const isImported = (sourceFile, type, paths) => {
     });
 };
 export const generateUserDefinedCondition = (root, content) => {
-    const sourceFile = createSourceFile('conditions.ts', content, ScriptTarget.ESNext);
-    sourceFile.getChildren().map(it => it);
-    const exportedVariables = sourceFile.statements.filter(it => it.kind === SyntaxKind.VariableStatement &&
-        it.modifiers?.some(it => it.kind === SyntaxKind.ExportKeyword));
-    const contextImported = isImported(sourceFile, 'GQLContext', [
-        '"./context"',
-        '"./context.js"',
-    ]);
-    const customConditionImported = isImported(sourceFile, 'CustomCondition', [
-        '"sasat"',
-    ]);
     const customConditionNames = unique(root.entities.flatMap(it => [
         ...it.references.flatMap(it => it.joinCondition
             .filter(it => it.kind === 'custom')
@@ -36,6 +28,19 @@ export const generateUserDefinedCondition = (root, content) => {
             .filter(it => it.kind === 'custom')
             .map(it => it.conditionName)),
     ]));
+    if (customConditionNames.length === 0)
+        return null;
+    const sourceFile = createSourceFile('conditions.ts', content, ScriptTarget.ESNext);
+    sourceFile.getChildren().map(it => it);
+    const exportedVariables = sourceFile.statements.filter(it => it.kind === SyntaxKind.VariableStatement &&
+        it.modifiers?.some(it => it.kind === SyntaxKind.ExportKeyword));
+    const contextImported = isImported(sourceFile, 'GQLContext', [
+        './context',
+        './context.js',
+    ]);
+    const customConditionImported = isImported(sourceFile, 'CustomCondition', [
+        'sasat',
+    ]);
     const statements = [];
     customConditionNames.forEach(conditionName => {
         const exists = exportedVariables.some(it => {

package/lib/generatorv2/codegen/tscodegen_v2.d.ts

@@ -17,5 +17,5 @@ export declare class TsCodegen_v2 {
     generateGQLContext: (root: RootNode) => string;
     generateFiles: (root: RootNode) => FileData[];
     generateOnceFiles: () => FileData[];
-    generateConditions: (root: RootNode, currentFile: string) => string;
+    generateConditions: (root: RootNode, currentFile: string) => string | null;
 }

package/lib/generatorv2/codegen_v2.js

@@ -5,7 +5,6 @@ import { mkDirIfNotExist, writeFileIfNotExist } from '../util/fsUtil.js';
 import { TsCodegen_v2 } from './codegen/tscodegen_v2.js';
 import { parse } from './parse.js';
 import { Directory } from './directory.js';
-import { readFileSync, writeFileSync } from 'fs';
 const { emptyDir, writeFile } = fs;
 export class CodeGen_v2 {
     constructor(store) {
@@ -70,8 +69,11 @@ export class CodeGen_v2 {
     }
     async generateCondition(rootNode) {
         const filePath = this.getFullPath(this.outDir, 'conditions');
-        await writeFileIfNotExist(filePath, '');
-        const content = readFileSync(filePath).toString();
-        writeFileSync(filePath, this.codeGen.generateConditions(rootNode, content));
+        const content = fs.existsSync(filePath)
+            ? fs.readFileSync(filePath).toString()
+            : '';
+        const nextContent = this.codeGen.generateConditions(rootNode, content);
+        if (nextContent)
+            fs.writeFileSync(filePath, nextContent);
     }
 }

package/lib/generatorv2/nodes/entityNode.d.ts

@@ -4,7 +4,7 @@ import { Table, TableHandler } from '../../migration/serializable/table.js';
 import { ReferenceColumn } from '../../migration/serializable/column.js';
 import { SerializedColumn } from '../../migration/serialized/serializedColumn.js';
 import { EntityName } from './entityName.js';
-import { GqlPrimitive } from '../scripts/gqlTypes.js';
+import { GQLPrimitive } from '../scripts/gqlTypes.js';
 import { VirtualRelation } from '../../migration/data/virtualRelation.js';
 import { JoinConditionNode } from './JoinConditionNode.js';
 import { GQLQuery } from '../../migration/data/GQLOption.js';
@@ -57,7 +57,7 @@ export declare type SubTypeNode = {
 export declare type FieldNode = {
     fieldName: string;
     columnName: string;
-    gqlType: GqlPrimitive | string;
+    gqlType: GQLPrimitive | string;
     dbType: DBColumnTypes;
     isNullable: boolean;
     isArray: boolean;
@@ -84,6 +84,6 @@ declare type PrimitiveParameterNode = {
     fieldName: string;
     columnName: string;
     dbtype: DBColumnTypes;
-    gqltype: GqlPrimitive;
+    gqltype: GQLPrimitive;
 };
 export {};

package/lib/generatorv2/nodes/subscriptionNode.d.ts

@@ -1,6 +1,6 @@
 import { ArgNode, TypeNode } from './typeNode.js';
 import { EntityName } from './entityName.js';
-import { GqlPrimitive } from '../scripts/gqlTypes.js';
+import { GQLPrimitive } from '../scripts/gqlTypes.js';
 declare type MutationType = 'create' | 'delete' | 'update';
 export declare type SubscriptionNode = {
     gqlEnabled: boolean;
@@ -14,6 +14,6 @@ export declare type SubscriptionNode = {
 };
 export declare type SubscriptionFilterNode = {
     field: string;
-    gqlType: GqlPrimitive;
+    gqlType: GQLPrimitive;
 };
 export {};

package/lib/generatorv2/parser/makeMutationNodes.js

@@ -1,5 +1,4 @@
 import { DBColumnTypes } from '../../migration/column/columnTypes.js';
-import { GqlPrimitive } from '../scripts/gqlTypes.js';
 export const makeMutationNodes = (store) => {
     return store.tables.flatMap(makeTableMutationNodes);
 };
@@ -56,7 +55,7 @@ const makeUpdateMutationNode = (table) => {
         mutationName: `update${table.getEntityName().name}`,
         refetch: !table.gqlOption.mutation.update.noReFetch,
         returnType: {
-            typeName: noRefetch ? GqlPrimitive.Boolean : table.getEntityName().name,
+            typeName: noRefetch ? 'Boolean' : table.getEntityName().name,
             dbType: noRefetch
                 ? DBColumnTypes.boolean
                 : undefined,
@@ -87,7 +86,7 @@ const makeDeleteMutationNode = (table) => {
         identifyFields: table.getPrimaryKeyColumns().map(it => it.fieldName()),
         refetch: false,
         returnType: {
-            typeName: GqlPrimitive.Boolean,
+            typeName: 'Boolean',
             dbType: DBColumnTypes.boolean,
             nullable: false,
             array: false,

package/lib/generatorv2/scripts/columnToGqlType.d.ts

@@ -1,3 +1,3 @@
-import { GqlPrimitive } from './gqlTypes.js';
+import { GQLPrimitive } from './gqlTypes.js';
 import { DBColumnTypes } from '../../migration/column/columnTypes.js';
-export declare const columnTypeToGqlPrimitive: (type: DBColumnTypes) => GqlPrimitive;
+export declare const columnTypeToGqlPrimitive: (type: DBColumnTypes) => GQLPrimitive;

package/lib/generatorv2/scripts/columnToGqlType.js

@@ -1,4 +1,3 @@
-import { GqlPrimitive } from './gqlTypes.js';
 import { DBColumnTypes } from '../../migration/column/columnTypes.js';
 export const columnTypeToGqlPrimitive = (type) => {
     switch (type) {
@@ -9,10 +8,10 @@ export const columnTypeToGqlPrimitive = (type) => {
         case DBColumnTypes.bigInt:
         case DBColumnTypes.decimal:
         case DBColumnTypes.year:
-            return GqlPrimitive.Int;
+            return 'Int';
         case DBColumnTypes.float:
         case DBColumnTypes.double:
-            return GqlPrimitive.Float;
+            return 'Float';
         case DBColumnTypes.char:
         case DBColumnTypes.varchar:
         case DBColumnTypes.text:
@@ -20,8 +19,8 @@ export const columnTypeToGqlPrimitive = (type) => {
         case DBColumnTypes.date:
         case DBColumnTypes.dateTime:
         case DBColumnTypes.timestamp:
-            return GqlPrimitive.String;
+            return 'String';
         case DBColumnTypes.boolean:
-            return GqlPrimitive.Boolean;
+            return 'Boolean';
     }
 };

package/lib/generatorv2/scripts/gqlTypes.d.ts

@@ -1,7 +1,2 @@
-export declare enum GqlPrimitive {
-    Int = "Int",
-    Float = "Float",
-    String = "String",
-    Boolean = "Boolean"
-}
-export declare const toTsType: (type: 'Int' | 'String' | 'Float' | string) => string;
+export declare type GQLPrimitive = 'Int' | 'Float' | 'String' | 'Boolean';
+export declare const toTsType: (type: GQLPrimitive | string) => string;

package/lib/generatorv2/scripts/gqlTypes.js

@@ -1,10 +1,3 @@
-export var GqlPrimitive;
-(function (GqlPrimitive) {
-    GqlPrimitive["Int"] = "Int";
-    GqlPrimitive["Float"] = "Float";
-    GqlPrimitive["String"] = "String";
-    GqlPrimitive["Boolean"] = "Boolean";
-})(GqlPrimitive || (GqlPrimitive = {}));
 export const toTsType = (type) => {
     switch (type) {
         case 'Int':
@@ -12,6 +5,8 @@ export const toTsType = (type) => {
             return 'number';
         case 'String':
             return 'string';
+        case 'Boolean':
+            return 'boolean';
         default:
             return type;
     }

package/lib/migration/serializable/column.d.ts

@@ -2,7 +2,7 @@ import { DBColumnTypes } from '../column/columnTypes.js';
 import { Serializable } from './serializable.js';
 import { Reference, SerializedColumn, SerializedNormalColumn, SerializedReferenceColumn } from '../serialized/serializedColumn.js';
 import { Table } from './table.js';
-import { GqlPrimitive } from '../../generatorv2/scripts/gqlTypes.js';
+import { GQLPrimitive } from '../../generatorv2/scripts/gqlTypes.js';
 export interface Column extends Serializable<SerializedColumn> {
     fieldName(): string;
     columnName(): string;
@@ -11,7 +11,7 @@ export interface Column extends Serializable<SerializedColumn> {
     isReference(): this is ReferenceColumn;
     isNullable(): boolean;
     tsType(): string;
-    gqlType(): GqlPrimitive;
+    gqlType(): GQLPrimitive;
     isNullableOnCreate(): boolean;
 }
 export declare class BaseColumn implements Column {
@@ -22,7 +22,7 @@ export declare class BaseColumn implements Column {
     columnName(): string;
     dataType(): DBColumnTypes;
     tsType(): string;
-    gqlType(): GqlPrimitive;
+    gqlType(): GQLPrimitive;
     isNullable(): boolean;
     isNullableOnCreate(): boolean;
     isReference(): this is ReferenceColumn;

package/lib/runtime/dsl/query/sql/hydrate.d.ts

@@ -1,6 +1,4 @@
 import { SqlValueType } from '../../../../db/connectors/dbClient.js';
-import { Query, QueryTable } from '../query.js';
-import { TableInfo } from '../createQueryResolveInfo.js';
 export declare type QueryResolveInfo = {
     tableAlias: string;
     isArray: boolean;
@@ -10,5 +8,3 @@ export declare type QueryResolveInfo = {
 };
 export declare type ResultRow = Record<string, SqlValueType>;
 export declare const hydrate: (data: ResultRow[], info: QueryResolveInfo) => unknown[];
-export declare const getQueryTableName: (table: QueryTable) => string;
-export declare const appendKeysToQuery: (query: Query, identifiableKeyMap: TableInfo) => Query;

package/lib/runtime/dsl/query/sql/hydrate.js

@@ -1,9 +1,4 @@
 import { SELECT_ALIAS_SEPARATOR } from './nodeToSql.js';
-import { QueryNodeKind } from '../query.js';
-import { QExpr } from '../../factory.js';
-const getUnique = (target, info) => info.keyAliases
-    .map(it => target[info.tableAlias + SELECT_ALIAS_SEPARATOR + it])
-    .join('_~_');
 const rowToObjs = (row) => {
     const objs = {};
     Object.entries(row).forEach(([key, value]) => {
@@ -15,80 +10,61 @@ const rowToObjs = (row) => {
     });
     return objs;
 };
-const hydrateRow = (info, objs) => {
-    const result = objs[info.tableAlias];
-    if (result[info.keyAliases[0]] === null)
-        return null;
-    info.joins.forEach(it => {
-        if (it.isArray) {
-            const child = hydrateRow(it, objs);
-            result[it.property] = child ? [child] : [];
-        }
-        else {
-            result[it.property] = hydrateRow(it, objs);
-        }
-    });
-    return result;
-};
-const findAndAppend = (base, info, objs) => {
+const getUnique = (obj, info) => info.keyAliases.map(it => obj[it]).join('_~_');
+const execTable = (info, objs, current) => {
+    let entity = objs[info.tableAlias];
+    if (entity[info.keyAliases[0]] == null)
+        entity = null;
+    let result;
+    let currentTarget;
     if (info.isArray) {
-        if (!base[info.property]) {
-            base[info.property] = [hydrateRow(info, objs)];
-            return true;
+        if (!current) {
+            result = entity == null ? [] : [entity];
+            currentTarget = entity;
         }
-        const tArr = base[info.property];
-        const target = tArr.find(item => item &&
-            info.keyAliases.every(key => item[key] === objs[info.tableAlias][key]));
-        if (!target) {
-            const child = hydrateRow(info, objs);
-            if (child)
-                tArr.push(child);
-            return true;
+        else {
+            currentTarget =
+                entity == null
+                    ? null
+                    : current.find((item) => item &&
+                        info.keyAliases.every(key => item[key] === entity[key]));
+            if (currentTarget) {
+                result = current;
+            }
+            else {
+                currentTarget = entity;
+                result = current;
+                if (currentTarget)
+                    result.push(currentTarget);
+            }
         }
-        else
-            return info.joins.some(info => findAndAppend(target, info, objs));
     }
-    if (base[info.property] !== undefined)
-        return false;
-    base[info.property] = hydrateRow(info, objs);
-    return true;
+    else {
+        currentTarget = current || entity;
+        result = currentTarget;
+    }
+    if (currentTarget !== null) {
+        info.joins.forEach(it => {
+            currentTarget[it.property] = execTable(it, objs, currentTarget[it.property]);
+        });
+    }
+    return result;
 };
 export const hydrate = (data, info) => {
     const result = [];
     const t0mapper = {};
+    info.isArray = false;
     data.forEach(row => {
-        const unique = getUnique(row, info);
         const objs = rowToObjs(row);
+        const currentObj = objs[info.tableAlias];
+        const unique = getUnique(currentObj, info);
         if (t0mapper[unique] === undefined) {
             t0mapper[unique] = result.length;
-            result.push(hydrateRow(info, objs));
+            result.push(execTable(info, objs, currentObj));
             return;
         }
         const base = result[t0mapper[unique]];
-        info.joins.some(info => findAndAppend(base, info, objs));
+        execTable(info, objs, base);
     });
     return result;
 };
-export const getQueryTableName = (table) => {
-    if (!table.subquery)
-        return table.name;
-    return getQueryTableName(table.query.from);
-};
-export const appendKeysToQuery = (query, identifiableKeyMap) => {
-    const getTables = (table) => [
-        table,
-        ...table.joins.flatMap(it => getTables(it.table)),
-    ];
-    const tables = getTables(query.from);
-    tables.forEach(table => {
-        const keys = identifiableKeyMap[getQueryTableName(table)].identifiableFields;
-        keys.forEach(key => {
-            if (!query.select.some(it => it.kind === QueryNodeKind.Field &&
-                it.table === table.alias &&
-                it.name === key)) {
-                query.select.push(QExpr.field(table.alias, key, table.alias + SELECT_ALIAS_SEPARATOR + key));
-            }
-        });
-    });
-    return query;
-};

package/lib/runtime/dsl/query/sql/hydrate2.d.ts

@@ -0,0 +1,12 @@
+import { SqlValueType } from '../../../../db/connectors/dbClient.js';
+import { QueryTable } from '../query.js';
+export declare type QueryResolveInfo = {
+    tableAlias: string;
+    isArray: boolean;
+    keyAliases: string[];
+    joins: QueryResolveInfo[];
+    property: string;
+};
+export declare type ResultRow = Record<string, SqlValueType>;
+export declare const hydrate: (data: ResultRow[], info: QueryResolveInfo) => unknown[];
+export declare const getQueryTableName: (table: QueryTable) => string;

package/lib/runtime/dsl/query/sql/hydrate2.js

@@ -0,0 +1,73 @@
+import { SELECT_ALIAS_SEPARATOR } from './nodeToSql.js';
+const rowToObjs = (row) => {
+    const objs = {};
+    Object.entries(row).forEach(([key, value]) => {
+        const [table, column] = key.split(SELECT_ALIAS_SEPARATOR);
+        if (!objs[table]) {
+            objs[table] = {};
+        }
+        objs[table][column] = value;
+    });
+    return objs;
+};
+const getUnique = (obj, info) => info.keyAliases
+    .map(it => obj[it])
+    .join('_~_');
+export const hydrate = (data, info) => {
+    const result = [];
+    const t0mapper = {};
+    info.isArray = false;
+    data.forEach(row => {
+        const objs = rowToObjs(row);
+        const currentObj = objs[info.tableAlias];
+        const unique = getUnique(currentObj, info);
+        if (t0mapper[unique] === undefined) {
+            t0mapper[unique] = result.length;
+            result.push(execTable(info, objs, currentObj));
+            return;
+        }
+        const base = result[t0mapper[unique]];
+        execTable(info, objs, base);
+    });
+    return result;
+};
+const execTable = (info, objs, current) => {
+    let entity = objs[info.tableAlias];
+    if (entity[info.keyAliases[0]] == null)
+        entity = null;
+    let result;
+    let currentTarget;
+    if (info.isArray) {
+        if (!current) {
+            result = entity == null ? [] : [entity];
+            currentTarget = entity;
+        }
+        else {
+            currentTarget = entity == null ? null : current.find((item) => item && info.keyAliases.every(key => item[key] === entity[key]));
+            if (currentTarget) {
+                result = current;
+            }
+            else {
+                currentTarget = entity;
+                result = current;
+                if (currentTarget)
+                    result.push(currentTarget);
+            }
+        }
+    }
+    else {
+        currentTarget = current || entity;
+        result = currentTarget;
+    }
+    if (currentTarget !== null) {
+        info.joins.forEach(it => {
+            currentTarget[it.property] = execTable(it, objs, currentTarget[it.property]);
+        });
+    }
+    return result;
+};
+export const getQueryTableName = (table) => {
+    if (!table.subquery)
+        return table.name;
+    return getQueryTableName(table.query.from);
+};

package/lib/runtime/dsl/replaceAliases.js

@@ -1,5 +1,4 @@
 import { QueryNodeKind, NO_ALIAS, } from './query/query.js';
-import { getQueryTableName } from './query/sql/hydrate.js';
 export const createAliasReplacer = (tableInfo, tableAliases = {}) => {
     const replaceAlias = (node) => {
         const map = {
@@ -96,3 +95,8 @@ export const replaceAliases = (query, tableInfo) => {
         offset: query.offset,
     };
 };
+const getQueryTableName = (table) => {
+    if (!table.subquery)
+        return table.name;
+    return getQueryTableName(table.query.from);
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.19.8",
+  "version": "0.19.11",
   "repository": "https://github.com/nin138/sasat.git",
   "author": "nin138 <ninian138@gmail.com>",
   "license": "MIT",