sasat 0.16.3 → 0.17.0

package/lib/generator/controller.js

@@ -52,7 +52,7 @@ export class CodeGenerateController {
             writeFile(this.getFullPath(this.generateDir, 'query'), this.codeGen.generateGqlQuery(rootNode)),
             writeFile(this.getFullPath(this.generateDir, 'mutation'), this.codeGen.generateGqlMutation(rootNode)),
             writeFile(this.getFullPath(this.generateDir, 'subscription'), this.codeGen.generateGqlSubscription(rootNode)),
-            writeFile(this.getFullPath(this.generateDir, 'context'), this.codeGen.generateGqlContext(rootNode)),
+            writeFile(this.getFullPath(this.generateDir, 'context'), this.codeGen.generateGQLContext(rootNode)),
         ];
     }
     generateFiles(rootNode) {

package/lib/generator/generator.d.ts

@@ -15,7 +15,7 @@ export interface CodeGenerator {
     generateGqlQuery(root: RootNode): string;
     generateGqlMutation(root: RootNode): string;
     generateGqlSubscription(root: RootNode): string;
-    generateGqlContext(root: RootNode): string;
+    generateGQLContext(root: RootNode): string;
     generateFiles(RootNode: RootNode): FileData;
     generateOnceFiles(RootNode: RootNode): FileData;
 }

package/lib/generator/ts/db/generatedRepositoryGenerator.js

@@ -104,7 +104,7 @@ export class GeneratedRepositoryGenerator {
                     : qExpr
                         .property('conditions')
                         .property('and')
-                        .call(...exps))))),
+                        .call(...exps))), tsg.identifier('context'))),
             ];
             const returnType = tsg
                 .typeRef('EntityResult', [
@@ -117,6 +117,7 @@ export class GeneratedRepositoryGenerator {
                 new Parameter(`fields?`, tsg
                     .typeRef(`${node.entityName}Fields`)
                     .importFrom(Directory.generatedPath(Directory.paths.generatedDataSource.db, 'fields'))),
+                tsg.parameter('context?', tsg.typeRef('GQLContext').importFrom(Directory.basePath(Directory.paths.generatedDataSource.db, 'context'))),
             ], new TypeReference('Promise', [
                 it.returnType.isArray
                     ? tsg.arrayType(returnType)

package/lib/generator/ts/generator.d.ts

@@ -12,7 +12,7 @@ export declare class TsCodeGenerator implements CodeGenerator {
     generateGqlResolver(root: RootNode): string;
     generateGqlMutation(root: RootNode): string;
     generateGqlSubscription(root: RootNode): string;
-    generateGqlContext(root: RootNode): string;
+    generateGQLContext(root: RootNode): string;
     generateFiles(root: RootNode): FileData;
     generateOnceFiles(): FileData;
 }

package/lib/generator/ts/generator.js

@@ -38,7 +38,7 @@ export class TsCodeGenerator {
     generateGqlSubscription(root) {
         return new SubscriptionGenerator().generate(root.mutations()).toString();
     }
-    generateGqlContext(root) {
+    generateGQLContext(root) {
         return new ContextGenerator().generate(root.contexts).toString();
     }
     generateFiles(root) {

package/lib/generator/ts/gql/contextGenerator.js

@@ -3,7 +3,7 @@ import { TsInterface } from '../code/node/interface.js';
 import { PropertySignature } from '../code/node/propertySignature.js';
 export class ContextGenerator {
     generate(contexts) {
-        return new TsFile(new TsInterface('BaseGqlContext')
+        return new TsFile(new TsInterface('BaseGQLContext')
             .addProperties(contexts.map(it => new PropertySignature(it.name, it.type.toTsType())))
             .export()).disableEsLint();
     }

package/lib/generator/ts/gql/mutationGenerator.js

@@ -29,7 +29,7 @@ export class MutationGenerator {
         return [
             tsg.parameter('_', tsg.typeRef('unknown')),
             tsg.parameter('params', paramType),
-            tsg.parameter(useContext || reFetch ? 'context' : '_1', tsg.typeRef('GqlContext').importFrom('../context')),
+            tsg.parameter(useContext || reFetch ? 'context' : '_1', tsg.typeRef('GQLContext').importFrom('../context')),
             tsg.parameter(reFetch ? 'info' : '_2', tsg.typeRef('GraphQLResolveInfo').importFrom('graphql')),
         ];
     }

package/lib/generator/ts/gql/queryGenerator.js

@@ -8,12 +8,14 @@ export class QueryGenerator {
             .export()).addImport(['GraphQLResolveInfo'], 'graphql').disableEsLint();
     }
     static createParams(node, query) {
+        const context = tsg.parameter('context', tsg.typeRef('GQLContext').importFrom('../context'));
+        const resolveInfo = tsg.parameter('info', tsg.typeRef('GraphQLResolveInfo'));
         if (query.queryParams.length === 0)
             return [
                 tsg.parameter('_1', tsg.typeRef('unknown')),
                 tsg.parameter('_2', tsg.typeRef('unknown')),
-                tsg.parameter('_3', tsg.typeRef('unknown')),
-                tsg.parameter('info', tsg.typeRef('GraphQLResolveInfo')),
+                context,
+                resolveInfo,
             ];
         if (query.isList) {
             return [
@@ -21,8 +23,8 @@ export class QueryGenerator {
                 tsg.parameter('params', tsg.typeLiteral([
                     tsg.propertySignature('option', query.queryParams[0].type.toTsType(), true, false),
                 ])),
-                tsg.parameter('_2', tsg.typeRef('unknown')),
-                tsg.parameter('info', tsg.typeRef('GraphQLResolveInfo')),
+                context,
+                resolveInfo,
             ];
         }
         const paramNames = query.queryParams.map(it => it.name);
@@ -31,8 +33,8 @@ export class QueryGenerator {
             tsg.parameter(`{ ${paramNames.join(',')} }`, node.entityName
                 .getTypeReference(Directory.paths.generated)
                 .pick(...paramNames)),
-            tsg.parameter('_2', tsg.typeRef('unknown')),
-            tsg.parameter('info', tsg.typeRef('GraphQLResolveInfo')),
+            context,
+            resolveInfo,
         ];
     }
     query(node, query) {
@@ -45,7 +47,7 @@ export class QueryGenerator {
             .identifier('gqlResolveInfoToField')
             .importFrom('sasat')
             .call(tsg.identifier('info'))
-            .as(node.entityName.fieldTypeRef(Directory.paths.generated)))));
+            .as(node.entityName.fieldTypeRef(Directory.paths.generated)), tsg.identifier('context'))));
     }
     listQuery(node, query) {
         const fields = tsg.identifier('fields');
@@ -63,7 +65,7 @@ export class QueryGenerator {
                 .as(node.entityName.fieldTypeRef(Directory.paths.generated))),
             tsg.if(option, tsg.return(ds
                 .property('findPageable')
-                .call(tsg.object(tsg.propertyAssign('numberOfItem', option.property('numberOfItem')), tsg.propertyAssign('offset', option.property('offset'))), fields))),
+                .call(tsg.object(tsg.propertyAssign('numberOfItem', option.property('numberOfItem')), tsg.propertyAssign('offset', option.property('offset'))), fields, tsg.identifier('undefined'), tsg.identifier('context')))),
             tsg.return(ds.property(query.repoMethodName).call(fields)),
         ];
         return tsg.propertyAssign(query.queryName, tsg.arrowFunc(QueryGenerator.createParams(node, query), undefined, tsg.block(...statements)));

package/lib/generator/ts/relationMapGenerator.js

@@ -4,12 +4,10 @@ import { Directory } from '../../constants/directory.js';
 import { KeywordTypeNode } from './code/node/type/typeKeyword.js';
 export class RelationMapGenerator {
     generate(root) {
-        return new TsFile(this.relationMap(root), this.tableInfo(root), tsg
-            .variable('const', 'dataStoreInfo', tsg.object(tsg.propertyAssign('tableInfo'), tsg.propertyAssign('relationMap')), tsg.typeRef('DataStoreInfo').importFrom('sasat'))
-            .export(), ...root.entities().flatMap(this.entityRelationType)).disableEsLint();
+        return new TsFile(this.relationMap(root), this.tableInfo(root), ...root.entities().flatMap(this.entityRelationType)).disableEsLint();
     }
     relationMap(root) {
-        return tsg.variable('const', tsg.identifier('relationMap'), tsg.object(...root.entities().map(it => this.entityRelationMap(it))), tsg.typeRef('RelationMap').importFrom('sasat'));
+        return tsg.variable('const', tsg.identifier('relationMap'), tsg.object(...root.entities().map(it => this.entityRelationMap(it))), tsg.typeRef('RelationMap').importFrom('sasat')).export();
     }
     entityRelationType(node) {
         const importEntity = (entity) => Directory.entityPath(Directory.paths.generated, entity);
@@ -57,12 +55,12 @@ export class RelationMapGenerator {
             .call(tsg.identifier('parentTableAlias'), tsg.string(parentColumn)), qExpr
             .property('field')
             .call(tsg.identifier('childTableAlias'), tsg.string(childColumn)))));
-        return tsg.propertyAssign(node.repository.tableName, tsg.object(...node.relations.map(rel => tsg.propertyAssign(rel.refPropertyName(), tsg.object(tsg.propertyAssign('table', tsg.string(rel.toTableName)), on(rel.fromField, rel.toField), tsg.propertyAssign('relation', tsg.string('One'))))), ...node
+        return tsg.propertyAssign(node.repository.tableName, tsg.object(...node.relations.map(rel => tsg.propertyAssign(rel.refPropertyName(), tsg.object(tsg.propertyAssign('table', tsg.string(rel.toTableName)), on(rel.fromColumnName, rel.toColumnName), tsg.propertyAssign('relation', tsg.string('One'))))), ...node
             .findReferencedRelations()
-            .map(rel => tsg.propertyAssign(rel.referencedByPropertyName(), tsg.object(tsg.propertyAssign('table', tsg.string(rel.parent.repository.tableName)), on(rel.toField, rel.fromField), tsg.propertyAssign('relation', tsg.string(rel.relation)))))));
+            .map(rel => tsg.propertyAssign(rel.referencedByPropertyName(), tsg.object(tsg.propertyAssign('table', tsg.string(rel.parent.repository.tableName)), on(rel.toColumnName, rel.fromColumnName), tsg.propertyAssign('relation', tsg.string(rel.relation)))))));
     }
     tableInfo(root) {
         const columnMap = (entity) => tsg.propertyAssign('columnMap', tsg.object(...entity.fields.map(field => tsg.propertyAssign(field.fieldName, tsg.string(field.columnName)))));
-        return tsg.variable('const', 'tableInfo', tsg.object(...root.repositories.map(repo => tsg.propertyAssign(repo.tableName, tsg.object(tsg.propertyAssign('identifiableKeys', tsg.array(repo.primaryKeys.map(tsg.string))), columnMap(repo.entity))))));
+        return tsg.variable('const', 'tableInfo', tsg.object(...root.repositories.map(repo => tsg.propertyAssign(repo.tableName, tsg.object(tsg.propertyAssign('identifiableKeys', tsg.array(repo.primaryKeys.map(tsg.string))), columnMap(repo.entity)))))).export();
     }
 }

package/lib/generator/ts/staticFiles.js

@@ -1,7 +1,7 @@
 import { ImportDeclaration } from './code/importDeclaration.js';
 const contextFile = `\
-${new ImportDeclaration(['BaseGqlContext'], './__generated__/context').toString()}
-export interface GqlContext extends BaseGqlContext {}
+${new ImportDeclaration(['BaseGQLContext'], './__generated__/context').toString()}
+export type GQLContext = BaseGQLContext & Record<string, never>;
 `;
 const pubsubFile = `\
 ${new ImportDeclaration(['PubSub', 'PubSubEngine'], 'graphql-subscriptions').toString()}
@@ -22,16 +22,17 @@ export const schema = {
 };
 `;
 const baseDBDataSourceFile = `\
-${new ImportDeclaration(['Fields', 'SasatRepository', 'EntityType'], 'sasat').toString()}
-${new ImportDeclaration(['dataStoreInfo'], './__generated__/relationMap').toString()}
+${new ImportDeclaration(['Fields', 'SasatDBDatasource', 'EntityType'], 'sasat').toString()}
+${new ImportDeclaration(['relationMap', 'tableInfo'], './__generated__/relationMap').toString()}
 
-export abstract class BaseDBDataSource<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields> extends SasatRepository<
+export abstract class BaseDBDataSource<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields> extends SasatDBDatasource<
   Entity,
   Creatable,
   Identifiable,
   EntityFields
 > {
-  protected maps = dataStoreInfo;
+  protected relationMap = relationMap
+  protected tableInfo = tableInfo;
 }
 `;
 export const staticFiles = [

package/lib/index.d.ts

@@ -1,4 +1,3 @@
-export { DataStoreInfo } from './runtime/dsl/query/createQueryResolveInfo.js';
 export { BooleanValueExpression } from './runtime/dsl/query/query.js';
 export { Relation } from './migration/data/relation.js';
 export { QExpr } from './runtime/dsl/factory.js';
@@ -8,7 +7,7 @@ export { gqlResolveInfoToField } from './runtime/gqlResolveInfoToField.js';
 export { ComparisonOperators } from './db/sql/expression/comparison.js';
 export { MigrationStore } from './migration/front/storeMigrator.js';
 export { SasatMigration } from './migration/front/migration.js';
-export { SasatRepository, EntityResult, EntityType, ListQueryOption, } from './runtime/sasatRepository.js';
+export { SasatDBDatasource, EntityResult, EntityType, ListQueryOption, } from './runtime/sasatDBDatasource.js';
 export { getCurrentDateTimeString } from './util/dateUtil.js';
 export { getDbClient } from './db/getDbClient.js';
 export { assignDeep } from './util/assignDeep.js';

package/lib/index.js

@@ -1,6 +1,6 @@
 export { QExpr } from './runtime/dsl/factory.js';
 export { gqlResolveInfoToField } from './runtime/gqlResolveInfoToField.js';
-export { SasatRepository, } from './runtime/sasatRepository.js';
+export { SasatDBDatasource, } from './runtime/sasatDBDatasource.js';
 export { getCurrentDateTimeString } from './util/dateUtil.js';
 export { getDbClient } from './db/getDbClient.js';
 export { assignDeep } from './util/assignDeep.js';

package/lib/migration/creators/tableCreator.d.ts

@@ -12,10 +12,10 @@ export interface TableBuilder {
     createdAt(): TableBuilder;
     updatedAt(): TableBuilder;
     addIndex(...columns: string[]): TableBuilder;
-    setGqlCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGqlUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGqlDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
-    setGqlContextColumn(columns: GqlFromContextParam[]): TableBuilder;
+    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
+    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
+    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
+    setGQLContextColumn(columns: GqlFromContextParam[]): TableBuilder;
 }
 export declare class TableCreator implements TableBuilder {
     tableName: string;
@@ -31,8 +31,8 @@ export declare class TableCreator implements TableBuilder {
     createdAt(): TableBuilder;
     updatedAt(): TableBuilder;
     addIndex(...columns: string[]): TableBuilder;
-    setGqlCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGqlUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
-    setGqlDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
-    setGqlContextColumn(columns: GqlFromContextParam[]): TableBuilder;
+    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
+    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
+    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
+    setGQLContextColumn(columns: GqlFromContextParam[]): TableBuilder;
 }

package/lib/migration/creators/tableCreator.js

@@ -50,20 +50,20 @@ export class TableCreator {
         this.table.addIndex(`index_${this.tableName}__${columns.join('_')}`, ...columns);
         return this;
     }
-    setGqlCreate(enabled, options) {
-        this.table.setGqlCreate(enabled, options);
+    setGQLCreate(enabled, options) {
+        this.table.setGQLCreate(enabled, options);
         return this;
     }
-    setGqlUpdate(enabled, options) {
-        this.table.setGqlUpdate(enabled, options);
+    setGQLUpdate(enabled, options) {
+        this.table.setGQLUpdate(enabled, options);
         return this;
     }
-    setGqlDelete(enabled, options) {
-        this.table.setGqlDelete(enabled, options);
+    setGQLDelete(enabled, options) {
+        this.table.setGQLDelete(enabled, options);
         return this;
     }
-    setGqlContextColumn(columns) {
-        this.table.setGqlContextColumn(columns);
+    setGQLContextColumn(columns) {
+        this.table.setGQLContextColumn(columns);
         return this;
     }
 }

package/lib/migration/front/tableMigrator.d.ts

@@ -14,10 +14,10 @@ export interface MigrationTable extends Table {
     addForeignKey(reference: Reference): MigrationTable;
     changeColumnType(columnName: string, type: DBType): MigrationTable;
     setDefault(columnName: string, value: string | number | null): MigrationTable;
-    setGqlCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGqlUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGqlDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
-    setGqlContextColumn(columns: GqlFromContextParam[]): MigrationTable;
+    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
+    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
+    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
+    setGQLContextColumn(columns: GqlFromContextParam[]): MigrationTable;
 }
 export declare class TableMigrator implements MigrationTable {
     private table;
@@ -33,10 +33,10 @@ export declare class TableMigrator implements MigrationTable {
     removeIndex(...columns: string[]): MigrationTable;
     addColumn(column: SerializedNormalColumn): MigrationTable;
     dropColumn(columnName: string): MigrationTable;
-    setGqlCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGqlUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
-    setGqlDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
-    setGqlContextColumn(columns: GqlFromContextParam[]): MigrationTable;
+    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
+    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
+    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
+    setGQLContextColumn(columns: GqlFromContextParam[]): MigrationTable;
     addForeignKey(reference: Reference): MigrationTable;
     changeColumnType(columnName: string, type: DBType): MigrationTable;
     protected tableExists(tableName: string): true;

package/lib/migration/front/tableMigrator.js

@@ -48,20 +48,20 @@ export class TableMigrator {
         this.store.addQuery(SqlCreator.dropColumn(this.tableName, columnName));
         return this;
     }
-    setGqlCreate(enabled, options) {
-        this.table.setGqlCreate(enabled, options);
+    setGQLCreate(enabled, options) {
+        this.table.setGQLCreate(enabled, options);
         return this;
     }
-    setGqlUpdate(enabled, options) {
-        this.table.setGqlUpdate(enabled, options);
+    setGQLUpdate(enabled, options) {
+        this.table.setGQLUpdate(enabled, options);
         return this;
     }
-    setGqlDelete(enabled, options) {
-        this.table.setGqlDelete(enabled, options);
+    setGQLDelete(enabled, options) {
+        this.table.setGQLDelete(enabled, options);
         return this;
     }
-    setGqlContextColumn(columns) {
-        this.table.setGqlContextColumn(columns);
+    setGQLContextColumn(columns) {
+        this.table.setGQLContextColumn(columns);
         return this;
     }
     addForeignKey(reference) {

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

@@ -38,10 +38,10 @@ export declare class TableHandler implements Table {
     hasColumn(columnName: string): boolean;
     isColumnPrimary(columnName: string): boolean;
     getEntityName(): EntityName;
-    setGqlCreate(enabled: boolean, options?: Partial<MutationOption>): void;
-    setGqlUpdate(enabled: boolean, options?: Partial<MutationOption>): void;
-    setGqlDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): void;
-    setGqlContextColumn(columns: GqlFromContextParam[]): void;
+    setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): void;
+    setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): void;
+    setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): void;
+    setGQLContextColumn(columns: GqlFromContextParam[]): void;
     getReferenceColumns(): ReferenceColumn[];
     addForeignKey(reference: Reference): void;
     changeType(columnName: string, type: DBColumnTypes): void;

package/lib/migration/serializable/table.js

@@ -129,7 +129,7 @@ export class TableHandler {
     getEntityName() {
         return new EntityName(TableHandler.tableNameToEntityName(this.tableName));
     }
-    setGqlCreate(enabled, options) {
+    setGQLCreate(enabled, options) {
         this._gqlOption = updateMutationOption(this._gqlOption, {
             create: {
                 ...defaultMutationOption,
@@ -138,7 +138,7 @@ export class TableHandler {
             },
         });
     }
-    setGqlUpdate(enabled, options) {
+    setGQLUpdate(enabled, options) {
         this._gqlOption = updateMutationOption(this._gqlOption, {
             update: {
                 ...defaultMutationOption,
@@ -147,7 +147,7 @@ export class TableHandler {
             },
         });
     }
-    setGqlDelete(enabled, options) {
+    setGQLDelete(enabled, options) {
         this._gqlOption = updateMutationOption(this._gqlOption, {
             delete: {
                 ...defaultMutationOption,
@@ -156,7 +156,7 @@ export class TableHandler {
             },
         });
     }
-    setGqlContextColumn(columns) {
+    setGQLContextColumn(columns) {
         this._gqlOption = updateMutationOption(this._gqlOption, {
             fromContextColumns: columns,
         });

package/lib/parser/node/relationNode.d.ts

@@ -11,6 +11,8 @@ export declare class RelationNode {
     readonly toTableName: string;
     readonly toEntityName: EntityName;
     readonly relation: Relation;
+    readonly fromColumnName: string;
+    readonly toColumnName: string;
     static fromReference(entity: EntityNode, ref: ReferenceColumn, targetFieldName: string): RelationNode;
     private constructor();
     refPropertyName(): string;

package/lib/parser/node/relationNode.js

@@ -2,7 +2,7 @@ import { EntityTypeNode } from './typeNode.js';
 import { TableHandler } from '../../migration/serializable/table.js';
 import { EntityName } from './entityName.js';
 export class RelationNode {
-    constructor(parent, relationName, fromField, toField, toTableName, toEntityName, relation) {
+    constructor(parent, relationName, fromField, toField, toTableName, toEntityName, relation, fromColumnName, toColumnName) {
         this.parent = parent;
         this.relationName = relationName;
         this.fromField = fromField;
@@ -10,9 +10,11 @@ export class RelationNode {
         this.toTableName = toTableName;
         this.toEntityName = toEntityName;
         this.relation = relation;
+        this.fromColumnName = fromColumnName;
+        this.toColumnName = toColumnName;
     }
     static fromReference(entity, ref, targetFieldName) {
-        return new RelationNode(entity, ref.data.reference.relationName, ref.data.fieldName, targetFieldName, ref.data.reference.targetTable, new EntityName(TableHandler.tableNameToEntityName(ref.data.reference.targetTable)), ref.data.reference.relation);
+        return new RelationNode(entity, ref.data.reference.relationName, ref.data.fieldName, targetFieldName, ref.data.reference.targetTable, new EntityName(TableHandler.tableNameToEntityName(ref.data.reference.targetTable)), ref.data.reference.relation, ref.data.columnName, ref.data.reference.targetColumn);
     }
     refPropertyName() {
         return this.relationName || this.fromField + this.toEntityName.name;

package/lib/runtime/dsl/query/createQueryResolveInfo.d.ts

@@ -3,7 +3,7 @@ import { QueryResolveInfo } from './sql/hydrate.js';
 import { Fields } from '../../field.js';
 export declare type RelationInfo = {
     table: string;
-    on: (parentTableAlias: string, childTableAlias: string) => BooleanValueExpression;
+    on: (parentTableAlias: string, childTableAlias: string, context?: any) => BooleanValueExpression;
     relation: 'One' | 'OneOrZero' | 'Many';
 };
 export declare type RelationMap = {
@@ -19,8 +19,4 @@ export declare type TableInfo = {
         };
     };
 };
-export declare type DataStoreInfo = {
-    tableInfo: TableInfo;
-    relationMap: RelationMap;
-};
 export declare const createQueryResolveInfo: (tableName: string, fields: Fields, map: RelationMap, tableInfo: TableInfo) => QueryResolveInfo;

package/lib/runtime/dsl/query/fieldToQuery.d.ts

@@ -1,5 +1,5 @@
 import { Query } from './query.js';
 import { RelationMap } from './createQueryResolveInfo.js';
 import { Fields } from '../../field.js';
-export declare const fieldToQuery: (tableName: string, fields: Fields, map: RelationMap) => Query;
+export declare const fieldToQuery: (tableName: string, fields: Fields, map: RelationMap) => Pick<Query, 'select' | 'from'>;
 export declare const createPagingInnerQuery: (tableName: string, fields: Fields, len: number, offset: number) => Query;

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

@@ -5,16 +5,18 @@ const getJoin = (from) => {
 export const queryToSql = (query) => {
     const select = query.select.map(Sql.select).join(', ');
     const join = getJoin(query.from).map(Sql.join).join(' ');
-    const where = query.where ? 'WHERE ' + Sql.booleanValue(query.where) : '';
+    const where = query.where ? ' WHERE ' + Sql.booleanValue(query.where) : '';
     const sort = query.sort && query.sort.length !== 0
         ? ' ORDER BY ' + Sql.sorts(query.sort)
         : '';
-    const offset = query.offset ? 'OFFSET ' + query.offset : '';
     const limit = query.limit ? ' LIMIT ' + query.limit : '';
+    const offset = query.offset ? ' OFFSET ' + query.offset : '';
+    if (offset && !limit)
+        throw new Error('LIMIT is required to use OFFSET.');
     return (`SELECT ${select} FROM ${Sql.table(query.from)}` +
         join +
         where +
         sort +
-        offset +
-        limit);
+        limit +
+        offset);
 };

package/lib/runtime/{sasatRepository.d.ts → sasatDBDatasource.d.ts}

@@ -1,7 +1,8 @@
-import { CommandResponse, DataStoreInfo } from '../index.js';
+import { CommandResponse, RelationMap } from '../index.js';
 import { Fields } from './field.js';
 import { ResultRow } from './dsl/query/sql/hydrate.js';
 import { SQLExecutor, SqlValueType } from '../db/connectors/dbClient.js';
+import { TableInfo } from './dsl/query/createQueryResolveInfo.js';
 import { BooleanValueExpression, Query, Sort } from './dsl/query/query.js';
 export declare type EntityType = Record<string, SqlValueType>;
 export declare type EntityResult<Entity, Identifiable> = Identifiable & Partial<Entity>;
@@ -16,9 +17,10 @@ export declare type ListQueryOption = {
     order?: string;
     asc?: boolean;
 };
-export declare abstract class SasatRepository<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields> implements Repository<Entity, Creatable, Identifiable> {
+export declare abstract class SasatDBDatasource<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields> implements Repository<Entity, Creatable, Identifiable> {
     protected client: SQLExecutor;
-    protected abstract maps: DataStoreInfo;
+    protected abstract relationMap: RelationMap;
+    protected abstract tableInfo: TableInfo;
     abstract readonly tableName: string;
     abstract readonly fields: string[];
     protected abstract readonly primaryKeys: string[];
@@ -34,13 +36,13 @@ export declare abstract class SasatRepository<Entity extends EntityType, Creatab
     first(fields?: EntityFields, option?: {
         where?: BooleanValueExpression;
         sort?: Sort[];
-    }): Promise<EntityResult<Entity, Identifiable> | null>;
+    }, context?: any): Promise<EntityResult<Entity, Identifiable> | null>;
     find(fields?: EntityFields, options?: {
         where?: BooleanValueExpression;
         sort?: Sort[];
         limit?: number;
         offset?: number;
-    }): Promise<EntityResult<Entity, Identifiable>[]>;
+    }, context?: unknown): Promise<EntityResult<Entity, Identifiable>[]>;
     findPageable(paging: {
         numberOfItem: number;
         where?: BooleanValueExpression;
@@ -51,7 +53,7 @@ export declare abstract class SasatRepository<Entity extends EntityType, Creatab
         sort?: Sort[];
         limit?: number;
         offset?: number;
-    }): Promise<EntityResult<Entity, Identifiable>[]>;
+    }, context?: unknown): Promise<EntityResult<Entity, Identifiable>[]>;
     private executeQuery;
     private createIdentifiableExpression;
 }

package/lib/runtime/{sasatRepository.js → sasatDBDatasource.js}

@@ -1,16 +1,15 @@
 import { getDbClient, QExpr, } from '../index.js';
-import { appendKeysToQuery, hydrate, } from './dsl/query/sql/hydrate.js';
 import { createQueryResolveInfo } from './dsl/query/createQueryResolveInfo.js';
 import { queryToSql } from './dsl/query/sql/queryToSql.js';
-import { createPagingInnerQuery, fieldToQuery, } from './dsl/query/fieldToQuery.js';
 import { replaceAliases } from './dsl/replaceAliases.js';
 import { createToSql, deleteToSql, updateToSql, } from './dsl/mutation/mutation.js';
-export class SasatRepository {
+import { createPagingFieldQuery, createQuery, runQuery } from "./sql/runQuery";
+export class SasatDBDatasource {
     constructor(client = getDbClient()) {
         this.client = client;
     }
     async query(query) {
-        const sql = queryToSql(replaceAliases(query, this.maps.tableInfo));
+        const sql = queryToSql(replaceAliases(query, this.tableInfo));
         return this.client.rawQuery(sql);
     }
     async create(entity) {
@@ -25,7 +24,7 @@ export class SasatRepository {
                 value,
             })),
         };
-        const response = await this.client.rawCommand(createToSql(dsl, this.maps.tableInfo));
+        const response = await this.client.rawCommand(createToSql(dsl, this.tableInfo));
         if (!this.autoIncrementColumn)
             return obj;
         return {
@@ -42,51 +41,40 @@ export class SasatRepository {
             })),
             where: this.createIdentifiableExpression(entity),
         };
-        return this.client.rawCommand(updateToSql(dsl, this.maps.tableInfo));
+        return this.client.rawCommand(updateToSql(dsl, this.tableInfo));
     }
     async delete(entity) {
         const dsl = {
             table: this.tableName,
             where: this.createIdentifiableExpression(entity),
         };
-        return this.client.rawCommand(deleteToSql(dsl, this.maps.tableInfo));
+        return this.client.rawCommand(deleteToSql(dsl, this.tableInfo));
     }
-    async first(fields, option) {
-        const result = await this.find(fields, option);
+    async first(fields, option, context) {
+        const result = await this.find(fields, option, context);
         if (result.length !== 0)
             return result[0];
         return null;
     }
-    async find(fields = { fields: this.fields }, options) {
-        const query = {
-            ...fieldToQuery(this.tableName, fields, this.maps.relationMap),
-            where: options?.where,
-            sort: options?.sort,
-            limit: options?.limit,
-            offset: options?.offset,
-        };
+    async find(fields = { fields: this.fields }, options, context) {
+        const query = createQuery(this.tableName, fields, options, this.tableInfo, this.relationMap, context);
         return this.executeQuery(query, fields);
     }
-    async findPageable(paging, fields = { fields: this.fields }, options) {
-        const partial = fieldToQuery(this.tableName, fields, this.maps.relationMap);
-        const innerQuery = createPagingInnerQuery(this.tableName, fields, paging.numberOfItem, paging.offset || 0);
-        const query = {
-            select: partial.select,
-            from: {
-                ...partial.from,
-                nameOrQuery: innerQuery,
-            },
-            where: options?.where,
-            sort: options?.sort,
-            limit: options?.limit,
-            offset: options?.offset,
-        };
+    async findPageable(paging, fields = { fields: this.fields }, options, context) {
+        const query = createPagingFieldQuery({
+            baseTableName: this.tableName,
+            fields,
+            tableInfo: this.tableInfo,
+            relationMap: this.relationMap,
+            pagingOption: paging,
+            queryOption: options,
+            context,
+        });
         return this.executeQuery(query, fields);
     }
     async executeQuery(query, fields) {
-        const info = createQueryResolveInfo(this.tableName, fields, this.maps.relationMap, this.maps.tableInfo);
-        const result = await this.query(appendKeysToQuery(query, this.maps.tableInfo));
-        return hydrate(result, info);
+        const info = createQueryResolveInfo(this.tableName, fields, this.relationMap, this.tableInfo);
+        return await runQuery(this.client, query, info);
     }
     createIdentifiableExpression(entity) {
         const expr = this.primaryKeys.map(it => {

package/lib/runtime/sql/runQuery.d.ts

@@ -0,0 +1,40 @@
+import { BooleanValueExpression, Query, Sort } from "../dsl/query/query.js";
+import { SQLExecutor } from "../../db/connectors/dbClient.js";
+import { RelationMap, TableInfo } from "../dsl/query/createQueryResolveInfo.js";
+import { Fields } from "../field.js";
+import { QueryResolveInfo } from "../dsl/query/sql/hydrate.js";
+import { ListQueryOption } from "../sasatDBDatasource.js";
+declare type QueryOptions = {
+    where?: BooleanValueExpression;
+    sort?: Sort[];
+    limit?: number;
+    offset?: number;
+};
+export declare const createQuery: (baseTableName: string, fields: Fields, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: any) => Query;
+declare type PagingOption = ListQueryOption & {
+    where?: BooleanValueExpression;
+};
+export declare const createPagingInnerQuery: (tableName: string, tableAlias: string, fields: Fields, option: PagingOption, tableInfo: TableInfo) => Query;
+export declare const runQuery: (client: SQLExecutor, query: Query, resolveInfo: QueryResolveInfo) => Promise<unknown[]>;
+declare type RunFieldQueryArg = {
+    client: SQLExecutor;
+    queryOptions: QueryOptions;
+    tableInfo: TableInfo;
+    relationMap: RelationMap;
+    baseTableName: string;
+    fields: Fields;
+};
+export declare const runFieldQuery: ({ client, tableInfo, baseTableName, fields, relationMap, queryOptions }: RunFieldQueryArg) => Promise<unknown[]>;
+declare type CreatePagingFieldQueryArg = {
+    baseTableName: string;
+    fields: Fields;
+    tableInfo: TableInfo;
+    relationMap: RelationMap;
+    queryOption?: QueryOptions;
+    pagingOption: ListQueryOption & {
+        where?: BooleanValueExpression;
+    };
+    context?: any;
+};
+export declare const createPagingFieldQuery: ({ baseTableName, fields, queryOption, pagingOption, tableInfo, relationMap, context, }: CreatePagingFieldQueryArg) => Query;
+export {};

package/lib/runtime/sql/runQuery.js

@@ -0,0 +1,67 @@
+import { createQueryResolveInfo } from "../dsl/query/createQueryResolveInfo.js";
+import { QExpr } from "../dsl/factory.js";
+import { unique } from "../util.js";
+import { queryToSql } from "../dsl/query/sql/queryToSql.js";
+import { hydrate } from "../dsl/query/sql/hydrate.js";
+import { SELECT_ALIAS_SEPARATOR } from "../dsl/query/sql/nodeToSql.js";
+export const createQuery = (baseTableName, fields, options, tableInfo, relationMap, context) => {
+    let tableCount = 0;
+    const select = [];
+    const resolveFields = (tableName, table) => {
+        const tableAlias = table.tableAlias || 't' + tableCount;
+        table.tableAlias = tableAlias;
+        tableCount++;
+        const info = tableInfo[tableName];
+        select.push(...unique([...table.fields, ...info.identifiableKeys])
+            .map(it => {
+            const realName = info.columnMap[it];
+            return QExpr.field(tableAlias, realName, tableAlias + SELECT_ALIAS_SEPARATOR + it);
+        }));
+        return QExpr.table(tableName, Object.entries(table.relations || {})
+            .map(([relationName, table]) => {
+            const current = tableCount;
+            const rel = relationMap[tableName][relationName];
+            return QExpr.join(resolveFields(rel.table, table), rel.on(tableAlias, table.tableAlias || 't' + current, context), "LEFT");
+        }), tableAlias);
+    };
+    const from = resolveFields(baseTableName, fields);
+    return {
+        select,
+        from,
+        ...options,
+    };
+};
+export const createPagingInnerQuery = (tableName, tableAlias, fields, option, tableInfo) => {
+    const map = tableInfo[tableName].columnMap;
+    return {
+        select: fields.fields.map(it => QExpr.field(tableAlias, map[it])),
+        from: QExpr.table(tableName, [], tableAlias),
+        limit: option.numberOfItem,
+        offset: option.offset,
+        where: option.where,
+        sort: option.order ? [
+            QExpr.sort(QExpr.field(tableAlias, map[option.order]), option.asc ? "ASC" : 'DESC')
+        ] : undefined,
+    };
+};
+export const runQuery = async (client, query, resolveInfo) => {
+    const resultRows = await client.rawQuery(queryToSql(query));
+    return hydrate(resultRows, resolveInfo);
+};
+export const runFieldQuery = async ({ client, tableInfo, baseTableName, fields, relationMap, queryOptions }) => {
+    const query = createQuery(baseTableName, fields, queryOptions, tableInfo, relationMap);
+    const resolveInfo = createQueryResolveInfo(baseTableName, fields, relationMap, tableInfo);
+    return runQuery(client, query, resolveInfo);
+};
+export const createPagingFieldQuery = ({ baseTableName, fields, queryOption, pagingOption, tableInfo, relationMap, context, }) => {
+    const tableAlias = fields.tableAlias || 't0';
+    const innerQuery = createPagingInnerQuery(baseTableName, tableAlias, fields, pagingOption, tableInfo);
+    const main = createQuery(baseTableName, fields, queryOption, tableInfo, relationMap, context);
+    return {
+        select: main.select,
+        from: {
+            ...main.from,
+            nameOrQuery: innerQuery,
+        },
+    };
+};

package/lib/runtime/util.d.ts

@@ -1,3 +1,4 @@
 export declare const pick: <T extends object>(target: T, keys: (keyof T)[]) => {
     [k: string]: T[keyof T];
 };
+export declare const unique: <T>(array: T[]) => T[];

package/lib/runtime/util.js

@@ -1 +1,10 @@
 export const pick = (target, keys) => Object.fromEntries(keys.map(key => [key, target[key]]));
+export const unique = (array) => {
+    const result = [];
+    for (let i = 0, l = array.length; i < l; i += 1) {
+        if (!result.includes(array[i])) {
+            result.push(array[i]);
+        }
+    }
+    return result;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sasat",
-  "version": "0.16.3",
+  "version": "0.17.0",
   "repository": "https://github.com/yanokunpei/sasat.git",
   "author": "yanokunpei <ninian138@gmail.com>",
   "license": "MIT",
@@ -65,7 +65,7 @@
     "tsconfig-paths": "4.1.0"
   },
   "peerDependencies": {
-    "apollo-server": "^2.0.0 || ^3.0.0",
+    "@apollo/server": "^4.0.0",
     "typescript": "^3.7.4 || ^4.0.0"
   },
   "lint-staged": {