sasat 0.17.4 → 0.18.0

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

@@ -2,7 +2,7 @@ import { TokenKind } from './lexer/lexer.js';
 import { camelize } from '../../../util/stringUtil.js';
 import { columnTypeToGqlPrimitive } from '../../../generator/gql/columnToGqlType.js';
 import { GqlPrimitive } from '../../../generator/gql/types.js';
-import { getDefaultGqlOption } from '../../../migration/data/gqlOption.js';
+import { getDefaultGqlOption } from '../../../migration/data/GQLOption.js';
 const splitArray = (array, callback) => {
     const indexes = [];
     array.forEach((it, i) => {

package/lib/generator/ts/code/factory.d.ts

@@ -45,7 +45,7 @@ export declare const tsg: {
     methodModifiers: () => MethodModifiers;
     propertyModifiers: () => PropertyModifiers;
     arrayType: (type: import("./node/type/type.js").TsType) => ArrayType;
-    intersectionType: (...args: (TypeReference | TypeLiteral)[]) => IntersectionType;
+    intersectionType: (...args: import("./node/type/type.js").TsType[]) => IntersectionType;
     unionType: (types: import("./node/type/type.js").TsType[]) => UnionType;
     typeAlias: (alias: string, type: import("./node/type/type.js").TsType) => TypeAliasDeclaration;
     typeLiteral: (properties?: PropertySignature[] | undefined) => TypeLiteral;

package/lib/generator/ts/code/node/type/intersectionType.d.ts

@@ -1,8 +1,7 @@
 import { TsCode } from '../../abstruct/tsCode.js';
-import { TypeLiteral } from './typeLiteral.js';
-import { TypeReference } from './typeReference.js';
+import { TsType } from "./type.js";
 export declare class IntersectionType extends TsCode {
     private readonly types;
-    constructor(...types: Array<TypeLiteral | TypeReference>);
+    constructor(...types: Array<TsType>);
     protected toTsString(): string;
 }

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

@@ -20,7 +20,7 @@ export class GeneratedRepositoryGenerator {
     generate() {
         const node = this.node;
         const entityPath = Directory.entityPath(Directory.paths.generatedDataSource.db, node.entityName);
-        return new TsFile(new Class(node.entityName.generatedDataSourceName())
+        return new TsFile(tsg.typeAlias('QueryResult', tsg.intersectionType(tsg.typeRef('Partial', [tsg.typeRef(node.entityName.entityWithRelationTypeName()).importFrom(Directory.generatedPath(Directory.paths.generatedDataSource.db, 'relationMap'))]), node.entityName.identifiableTypeReference(Directory.paths.generatedDataSource.db))), new Class(node.entityName.generatedDataSourceName())
             .export()
             .abstract()
             .extends(new ExtendsClause(tsg.typeRef('BaseDBDataSource', [
@@ -32,6 +32,7 @@ export class GeneratedRepositoryGenerator {
                 .typeRef(node.entityName.identifiableInterfaceName())
                 .importFrom(entityPath),
             node.entityName.fieldTypeRef(Directory.paths.generatedDataSource.db),
+            tsg.typeRef('QueryResult')
         ])).addImport(['BaseDBDataSource'], Directory.basePath(Directory.paths.generatedDataSource.db, 'baseDBDataSource')))
             .addProperty(...this.properties(node))
             .addMethod(this.getDefaultValueMethod(node), ...this.findMethods(node))).disableEsLint();
@@ -99,24 +100,22 @@ export class GeneratedRepositoryGenerator {
                 tsg.variable('const', 'tableName', tsg.identifier('fields?.tableAlias || "t0"')),
                 tsg.return(tsg
                     .identifier(it.returnType.isArray ? 'this.find' : 'this.first')
-                    .call(tsg.identifier('fields'), tsg.object().addProperties(tsg.propertyAssign('where', exps.length === 1
-                    ? exps[0]
-                    : qExpr
-                        .property('conditions')
-                        .property('and')
-                        .call(...exps))), tsg.identifier('context'))),
+                    .call(tsg.identifier('fields'), tsg.object().addProperties(tsg.spreadAssign(tsg.identifier('options')), tsg.propertyAssign('where', qExpr
+                    .property('conditions')
+                    .property('and')
+                    .call(...exps, tsg.identifier('options?').property('where')))), tsg.identifier('context'))),
             ];
-            const returnType = tsg
-                .typeRef('EntityResult', [
-                tsg.typeRef(node.entityName.name),
-                tsg.typeRef(node.entityName.identifiableInterfaceName()),
-            ])
-                .importFrom('sasat');
+            const returnType = tsg.typeRef('QueryResult');
             return new MethodDeclaration(it.name, [
                 ...it.params.map(it => new Parameter(it.name, it.type.toTsType())),
                 new Parameter(`fields?`, tsg
                     .typeRef(`${node.entityName}Fields`)
                     .importFrom(Directory.generatedPath(Directory.paths.generatedDataSource.db, 'fields'))),
+                tsg.parameter('options?', it.returnType.isArray ? tsg.typeRef('QueryOptions').importFrom('sasat')
+                    : tsg.typeRef('Omit', [
+                        tsg.typeRef('QueryOptions').importFrom('sasat'),
+                        tsg.typeRef('"offset" | "limit" | "sort"'),
+                    ])),
                 tsg.parameter('context?', tsg
                     .typeRef('GQLContext')
                     .importFrom(Directory.basePath(Directory.paths.generatedDataSource.db, 'context'))),

package/lib/generator/ts/fieldGenerator.js

@@ -15,7 +15,7 @@ export class FieldGenerator {
                 .typeRef(`keyof ${entity.entityName}`)
                 .addImport([entity.entityName.name], Directory.entityPath(Directory.paths.generated, entity.entityName)))),
             tsg.propertySignature('relations?', tsg.typeLiteral([
-                ...entity.relations.map(it => tsg.propertySignature(`${it.refPropertyName()}?`, tsg.typeRef(`${it.toEntityName}Fields`))),
+                ...entity.relations.map(it => tsg.propertySignature(`${it.refPropertyName()}?`, tsg.typeRef(`${it.to.entityName}Fields`))),
                 ...entity
                     .findReferencedRelations()
                     .map(it => tsg.propertySignature(`${it.referencedByPropertyName()}?`, tsg.typeRef(`${it.parent.entityName}Fields`))),

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

@@ -12,7 +12,7 @@ export class QueryGenerator {
     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)
+        if (query.queryParams.length === 0 || query.listType === 'all')
             return [
                 tsg.parameter('_1', tsg.typeRef('unknown')),
                 tsg.parameter('_2', tsg.typeRef('unknown')),
@@ -23,7 +23,7 @@ export class QueryGenerator {
             return [
                 tsg.parameter('_1', tsg.typeRef('unknown')),
                 tsg.parameter('params', tsg.typeLiteral([
-                    tsg.propertySignature('option', query.queryParams[0].type.toTsType(), true, false),
+                    tsg.propertySignature('option', query.queryParams[0].type.toTsType(), false, false),
                 ])),
                 context,
                 resolveInfo,
@@ -49,28 +49,37 @@ export class QueryGenerator {
             .identifier('gqlResolveInfoToField')
             .importFrom('sasat')
             .call(tsg.identifier('info'))
-            .as(node.entityName.fieldTypeRef(Directory.paths.generated)), tsg.identifier('context'))));
+            .as(node.entityName.fieldTypeRef(Directory.paths.generated)), tsg.identifier('undefined'), tsg.identifier('context'))));
     }
     listQuery(node, query) {
         const fields = tsg.identifier('fields');
+        const option = tsg.identifier('option');
         const ds = tsg.new(tsg
             .identifier(node.entityName.dataSourceName())
             .importFrom(Directory.dbDataSourcePath(Directory.paths.generated, node.entityName)));
-        const params = tsg.identifier('params');
-        const option = tsg.identifier('option');
-        const statements = [
-            tsg.variable('const', tsg.identifier('{ option }'), params),
-            tsg.variable('const', fields, tsg
-                .identifier('gqlResolveInfoToField')
-                .importFrom('sasat')
-                .call(tsg.identifier('info'))
-                .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, tsg.identifier('undefined'), tsg.identifier('context')))),
-            tsg.return(ds.property(query.repoMethodName).call(fields, tsg.identifier('undefined'), tsg.identifier('context'))),
-        ];
-        return tsg.propertyAssign(query.queryName, tsg.arrowFunc(QueryGenerator.createParams(node, query), undefined, tsg.block(...statements)));
+        const constInfo = tsg.variable('const', fields, tsg
+            .identifier('gqlResolveInfoToField')
+            .importFrom('sasat')
+            .call(tsg.identifier('info'))
+            .as(node.entityName.fieldTypeRef(Directory.paths.generated)));
+        const all = () => {
+            return [
+                constInfo,
+                tsg.return(ds
+                    .property(query.repoMethodName)
+                    .call(fields, tsg.identifier('undefined'), tsg.identifier('context'))),
+            ];
+        };
+        const pageable = () => {
+            return [
+                constInfo,
+                tsg.variable('const', tsg.identifier('{ option }'), tsg.identifier('params')),
+                tsg.return(ds
+                    .property('findPageable')
+                    .call(tsg.object(tsg.propertyAssign('numberOfItem', option.property('numberOfItem')), tsg.propertyAssign('offset', option.property('offset'))), fields, tsg.identifier('undefined'), tsg.identifier('context'))),
+            ];
+        };
+        return tsg.propertyAssign(query.queryName, tsg.arrowFunc(QueryGenerator.createParams(node, query), undefined, tsg.block(...(query.listType === 'paging' ? pageable() : all()))));
     }
     entity(node) {
         return node.queries.map(it => (it.isList ? this.listQuery : this.query)(node, it));

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

@@ -9,8 +9,9 @@ import { FindMethodNode } from '../../../parser/node/findMethod.js';
 export class ResolverGenerator {
     constructor() {
         this.entityResolver = (node) => {
-            return tsg.propertyAssign(node.entityName.name, tsg.object(...node.relations.map(relation => this.relationProperty(relation)), ...node
+            return tsg.propertyAssign(node.entityName.name, tsg.object(...node.relations.filter(it => it.to.gqlOption.enabled).map(relation => this.relationProperty(relation)), ...node
                 .findReferencedRelations()
+                .filter(it => it.from.gqlOption.enabled)
                 .map(relation => this.referencedByProperty(relation))));
         };
     }
@@ -23,27 +24,27 @@ export class ResolverGenerator {
                 .importFrom('./relationMap')),
         ], undefined, tsg.block(tsg.if(tsg.binary(tsg.identifier(paramName).property(propertyName), '!==', tsg.identifier('undefined')), tsg.return(tsg.identifier(paramName).property(propertyName))), tsg.return(tsg
             .new(tsg
-            .identifier(relation.toEntityName.dataSourceName())
-            .importFrom(Directory.dbDataSourcePath(Directory.paths.generated, relation.toEntityName)))
-            .property(FindMethodNode.paramsToName(relation.toField))
+            .identifier(relation.to.entityName.dataSourceName())
+            .importFrom(Directory.dbDataSourcePath(Directory.paths.generated, relation.to.entityName)))
+            .property(FindMethodNode.paramsToName(relation.to.field))
             .call(tsg
             .identifier(paramName)
-            .property(relation.fromField)
+            .property(relation.from.field)
             .nonNull())))));
     }
     referencedByProperty(relation) {
-        const paramName = relation.toEntityName.lowerCase();
+        const paramName = relation.to.entityName.lowerCase();
         const propertyName = relation.referencedByPropertyName();
         return tsg.propertyAssign(propertyName, tsg.arrowFunc([
             tsg.parameter(paramName, tsg
-                .typeRef(relation.toEntityName.resultType())
+                .typeRef(relation.to.entityName.resultType())
                 .importFrom('./relationMap')),
         ], undefined, tsg.block(tsg.if(tsg.binary(tsg.identifier(paramName).property(propertyName), '!==', tsg.identifier('undefined')), tsg.return(tsg.identifier(paramName).property(propertyName))), tsg.return(tsg
             .new(tsg
             .identifier(relation.parent.entityName.dataSourceName())
             .importFrom(Directory.dbDataSourcePath(Directory.paths.generated, relation.parent.entityName)))
-            .property(FindMethodNode.paramsToName(relation.fromField))
-            .call(tsg.identifier(paramName).property(relation.toField).nonNull())))));
+            .property(FindMethodNode.paramsToName(relation.from.field))
+            .call(tsg.identifier(paramName).property(relation.to.field).nonNull())))));
     }
     generate(root) {
         const hasSubscription = root.mutations().some(it => it.subscribed);
@@ -53,6 +54,6 @@ export class ResolverGenerator {
         ];
         if (hasSubscription)
             properties.push(new PropertyAssignment('Subscription', new Identifier('subscription').importFrom('./subscription')));
-        return new TsFile(new VariableDeclaration('const', new Identifier('resolvers'), new ObjectLiteral(...properties, new SpreadAssignment(new ObjectLiteral(...root.entities().map(this.entityResolver))))).export()).disableEsLint();
+        return new TsFile(new VariableDeclaration('const', new Identifier('resolvers'), new ObjectLiteral(...properties, new SpreadAssignment(new ObjectLiteral(...root.entities().filter(it => it.gqlEnabled()).map(this.entityResolver))))).export()).disableEsLint();
     }
 }

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

@@ -4,7 +4,7 @@ import { tsg } from '../code/factory.js';
 import { MutationNode } from '../../../parser/node/gql/mutationNode.js';
 export class TypeDefGenerator {
     generate(root) {
-        const typeDefs = root.entities().flatMap(it => it.allTypeDefs());
+        const typeDefs = root.entities().filter(it => it.gqlEnabled()).flatMap(it => it.allTypeDefs());
         const types = [
             ...this.createTypes(typeDefs),
             this.createQuery(root.queries()),

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

@@ -3,6 +3,7 @@ import { RootNode } from '../../parser/node/rootNode.js';
 export declare class RelationMapGenerator {
     generate(root: RootNode): TsFile;
     private relationMap;
+    private referencedRelationType;
     private entityRelationType;
     private entityRelationMap;
     private tableInfo;

package/lib/generator/ts/relationMapGenerator.js

@@ -4,26 +4,29 @@ 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), ...root.entities().flatMap(this.entityRelationType)).disableEsLint();
+        return new TsFile(this.relationMap(root), this.tableInfo(root), ...root.entities().flatMap(it => this.entityRelationType(it))).disableEsLint();
     }
     relationMap(root) {
         return tsg
             .variable('const', tsg.identifier('relationMap'), tsg.object(...root.entities().map(it => this.entityRelationMap(it))), tsg.typeRef('RelationMap').importFrom('sasat'))
             .export();
     }
+    referencedRelationType(node) {
+        const type = tsg.intersectionType(tsg.typeRef('Partial', [node.parent.entityName.getTypeReference(Directory.paths.generated)]), node.parent.entityName.identifiableTypeReference(Directory.paths.generated));
+        return tsg.propertySignature(node.referencedByPropertyName(), node.relation === 'Many' ? tsg.arrayType(type) : type);
+    }
     entityRelationType(node) {
         const importEntity = (entity) => Directory.entityPath(Directory.paths.generated, entity);
         const typeProperties = [
-            ...node.relations.map(it => tsg.propertySignature(it.refPropertyName(), it
-                .refType()
-                .toTsType()
-                .addImport([it.toEntityName.name], importEntity(it.toEntityName)))),
+            ...node.relations.map(it => tsg.propertySignature(it.refPropertyName(), tsg.intersectionType(tsg.typeRef('Partial', [
+                tsg.intersectionType(it
+                    .refType()
+                    .toTsType()
+                    .addImport([it.to.entityName.name], importEntity(it.to.entityName)), tsg.typeRef(it.to.entityName.relationTypeName())),
+            ]), it.to.entityName.identifiableTypeReference(Directory.paths.generated)))),
             ...node
                 .findReferencedRelations()
-                .map(it => tsg.propertySignature(it.referencedByPropertyName(), it
-                .referenceByType()
-                .toTsType()
-                .addImport([it.parent.entityName.name], importEntity(it.parent.entityName)))),
+                .map(it => this.referencedRelationType(it)),
         ];
         return [
             tsg
@@ -57,9 +60,9 @@ 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.fromColumnName, rel.toColumnName), 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.to.tableName)), on(rel.from.columnName, rel.to.columnName), 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.toColumnName, rel.fromColumnName), 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.to.columnName, rel.from.columnName), 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)))));

package/lib/generator/ts/staticFiles.js

@@ -25,13 +25,14 @@ const baseDBDataSourceFile = `\
 ${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 SasatDBDatasource<
-  Entity,
+export abstract class BaseDBDataSource<
+  Entity extends EntityType,
   Creatable,
   Identifiable,
-  EntityFields
-> {
-  protected relationMap = relationMap
+  EntityFields extends Fields,
+  QueryResult extends Partial<Entity> & Identifiable,
+> extends SasatDBDatasource<Entity, Creatable, Identifiable, EntityFields, QueryResult> {
+  protected relationMap = relationMap;
   protected tableInfo = tableInfo;
 }
 `;

package/lib/generator/ts/tsValueString.js

@@ -9,7 +9,7 @@ export const tsValueString = (value) => {
     if (typeof value === 'boolean')
         return '' + value;
     if (typeof value === 'string')
-        return `'${value.replace("'", "\\'")}'`;
+        return `'${value.replaceAll("'", "\\'")}'`;
     if (typeof value === 'bigint')
         return '' + value;
     if (typeof value === 'function')

package/lib/index.d.ts

@@ -1,4 +1,4 @@
-export { BooleanValueExpression } from './runtime/dsl/query/query.js';
+export { BooleanValueExpression, Query, LockMode, } from './runtime/dsl/query/query.js';
 export { Relation } from './migration/data/relation.js';
 export { QExpr } from './runtime/dsl/factory.js';
 export { RelationMap } from './runtime/dsl/query/createQueryResolveInfo.js';
@@ -7,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 { SasatDBDatasource, EntityResult, EntityType, ListQueryOption, } from './runtime/sasatDBDatasource.js';
+export { SasatDBDatasource, EntityResult, EntityType, ListQueryOption, QueryOptions, } 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

@@ -2,7 +2,7 @@ import { ColumnCreator } from './columnCreator.js';
 import { ColumnBuilder } from './columnBuilder.js';
 import { Reference } from '../serialized/serializedColumn.js';
 import { TableHandler } from '../serializable/table.js';
-import { GqlFromContextParam, MutationOption } from '../data/gqlOption.js';
+import { GqlFromContextParam, GQLOption, MutationOption } from '../data/GQLOption.js';
 import { DataStore } from '../dataStore.js';
 export interface TableBuilder {
     column(columnName: string): ColumnCreator;
@@ -16,6 +16,8 @@ export interface TableBuilder {
     setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
     setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;
     setGQLContextColumn(columns: GqlFromContextParam[]): TableBuilder;
+    enableGQL(): TableBuilder;
+    setGQLOption(option: Partial<GQLOption>): TableBuilder;
 }
 export declare class TableCreator implements TableBuilder {
     tableName: string;
@@ -31,6 +33,8 @@ export declare class TableCreator implements TableBuilder {
     createdAt(): TableBuilder;
     updatedAt(): TableBuilder;
     addIndex(...columns: string[]): TableBuilder;
+    enableGQL(): TableBuilder;
+    setGQLOption(option: Partial<GQLOption>): TableBuilder;
     setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
     setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): TableBuilder;
     setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): TableBuilder;

package/lib/migration/creators/tableCreator.js

@@ -50,6 +50,17 @@ export class TableCreator {
         this.table.addIndex(`index_${this.tableName}__${columns.join('_')}`, ...columns);
         return this;
     }
+    enableGQL() {
+        this.table.setGQLOption({
+            ...this.table.gqlOption,
+            enabled: true,
+        });
+        return this;
+    }
+    setGQLOption(option) {
+        this.table.setGQLOption(option);
+        return this;
+    }
     setGQLCreate(enabled, options) {
         this.table.setGQLCreate(enabled, options);
         return this;

package/lib/migration/data/{gqlOption.d.ts → GQLOption.d.ts}

@@ -10,7 +10,12 @@ export declare type MutationOption = {
     subscription: boolean;
     subscriptionFilter: string[];
 };
-export interface GqlOption {
+export interface GQLOption {
+    enabled: boolean;
+    query: {
+        find: boolean;
+        list: false | 'all' | 'paging';
+    };
     mutation: {
         create: MutationOption & Enabled;
         update: MutationOption & Enabled;
@@ -24,6 +29,6 @@ export declare const defaultMutationOption: {
     subscription: boolean;
     subscriptionFilter: never[];
 };
-export declare const getDefaultGqlOption: () => GqlOption;
-export declare const updateMutationOption: (option: GqlOption, mutation: Partial<GqlOption['mutation']>) => GqlOption;
+export declare const getDefaultGqlOption: () => GQLOption;
+export declare const updateMutationOption: (option: GQLOption, mutation: Partial<GQLOption['mutation']>) => GQLOption;
 export {};

package/lib/migration/data/{gqlOption.js → GQLOption.js}

@@ -5,6 +5,11 @@ export const defaultMutationOption = {
     subscriptionFilter: [],
 };
 export const getDefaultGqlOption = () => ({
+    enabled: false,
+    query: {
+        find: true,
+        list: 'all',
+    },
     mutation: {
         create: defaultMutationOption,
         update: defaultMutationOption,

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

@@ -1,7 +1,7 @@
 import { StoreMigrator } from './storeMigrator.js';
 import { Table, TableHandler } from '../serializable/table.js';
 import { Reference, SerializedColumn, SerializedNormalColumn } from '../serialized/serializedColumn.js';
-import { GqlFromContextParam, MutationOption } from '../data/gqlOption.js';
+import { GqlFromContextParam, GQLOption, MutationOption } from '../data/GQLOption.js';
 import { Column } from '../serializable/column.js';
 import { SerializedTable } from '../serialized/serializedStore.js';
 import { DBType } from '../column/columnTypes.js';
@@ -18,6 +18,8 @@ export interface MigrationTable extends Table {
     setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
     setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): MigrationTable;
     setGQLContextColumn(columns: GqlFromContextParam[]): MigrationTable;
+    enableGQL(): MigrationTable;
+    setGQLOption(option: GQLOption): MigrationTable;
 }
 export declare class TableMigrator implements MigrationTable {
     private table;
@@ -35,10 +37,13 @@ export declare class TableMigrator implements MigrationTable {
     dropColumn(columnName: string): MigrationTable;
     setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
     setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): MigrationTable;
+    enableGQL(): MigrationTable;
+    setGQLOption(option: GQLOption): 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;
     setDefault(columnName: string, value: string | number | null): MigrationTable;
+    get gqlOption(): GQLOption;
 }

package/lib/migration/front/tableMigrator.js

@@ -56,6 +56,17 @@ export class TableMigrator {
         this.table.setGQLUpdate(enabled, options);
         return this;
     }
+    enableGQL() {
+        this.table.setGQLOption({
+            ...this.table.gqlOption,
+            enabled: true,
+        });
+        return this;
+    }
+    setGQLOption(option) {
+        this.table.setGQLOption(option);
+        return this;
+    }
     setGQLDelete(enabled, options) {
         this.table.setGQLDelete(enabled, options);
         return this;
@@ -99,4 +110,7 @@ export class TableMigrator {
         this.store.addQuery(`ALTER TABLE ${this.tableName} ALTER ${columnName} SET DEFAULT ${SqlString.escape(value)}`);
         return this;
     }
+    get gqlOption() {
+        return this.table.gqlOption;
+    }
 }

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

@@ -3,13 +3,14 @@ import { SerializedTable } from '../serialized/serializedStore.js';
 import { BaseColumn, Column, ReferenceColumn } from './column.js';
 import { Reference, SerializedColumn } from '../serialized/serializedColumn.js';
 import { DBIndex } from '../data/index.js';
-import { GqlFromContextParam, GqlOption, MutationOption } from '../data/gqlOption.js';
+import { GqlFromContextParam, GQLOption, MutationOption } from '../data/GQLOption.js';
 import { EntityName } from '../../parser/node/entityName.js';
 import { DataStore } from '../dataStore.js';
 import { DBColumnTypes } from '../column/columnTypes.js';
 export interface Table extends Serializable<SerializedTable> {
     column(columnName: string): Column;
     tableName: string;
+    gqlOption: GQLOption;
 }
 export declare class TableHandler implements Table {
     store: DataStore;
@@ -22,7 +23,7 @@ export declare class TableHandler implements Table {
     readonly uniqueKeys: string[][];
     readonly tableName: string;
     private _gqlOption;
-    get gqlOption(): GqlOption;
+    get gqlOption(): GQLOption;
     constructor(table: Partial<SerializedTable> & Pick<SerializedTable, 'tableName'>, store: DataStore);
     column(columnName: string): Column;
     addColumn(column: BaseColumn, isPrimary?: boolean, isUnique?: boolean): void;
@@ -40,6 +41,7 @@ export declare class TableHandler implements Table {
     getEntityName(): EntityName;
     setGQLCreate(enabled: boolean, options?: Partial<MutationOption>): void;
     setGQLUpdate(enabled: boolean, options?: Partial<MutationOption>): void;
+    setGQLOption(option: Partial<GQLOption>): void;
     setGQLDelete(enabled: boolean, options?: Partial<Omit<MutationOption, 'noReFetch'>>): void;
     setGQLContextColumn(columns: GqlFromContextParam[]): void;
     getReferenceColumns(): ReferenceColumn[];

package/lib/migration/serializable/table.js

@@ -4,7 +4,7 @@ import { SqlString } from '../../runtime/sql/sqlString.js';
 import { SasatError } from '../../error.js';
 import { referenceToSql, } from '../serialized/serializedColumn.js';
 import { DBIndex } from '../data/index.js';
-import { defaultMutationOption, getDefaultGqlOption, updateMutationOption, } from '../data/gqlOption.js';
+import { defaultMutationOption, getDefaultGqlOption, updateMutationOption, } from '../data/GQLOption.js';
 import { assembleColumn } from '../functions/assembleColumn.js';
 import { EntityName } from '../../parser/node/entityName.js';
 export class TableHandler {
@@ -147,6 +147,9 @@ export class TableHandler {
             },
         });
     }
+    setGQLOption(option) {
+        this._gqlOption = { ...this.gqlOption, ...option };
+    }
     setGQLDelete(enabled, options) {
         this._gqlOption = updateMutationOption(this._gqlOption, {
             delete: {

package/lib/migration/serialized/serializedStore.d.ts

@@ -1,6 +1,6 @@
 import { SerializedColumn } from './serializedColumn.js';
 import { Index } from '../data/index.js';
-import { GqlOption } from '../data/gqlOption.js';
+import { GQLOption } from '../data/GQLOption.js';
 export interface SerializedStore {
     tables: SerializedTable[];
 }
@@ -10,5 +10,5 @@ export interface SerializedTable {
     uniqueKeys: string[][];
     indexes: Index[];
     tableName: string;
-    gqlOption: GqlOption;
+    gqlOption: GQLOption;
 }

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

@@ -20,4 +20,5 @@ export declare class EntityNode {
     onCreateOptionalFields(): FieldNode[];
     hasDefaultValueFields(): FieldNode[];
     findReferencedRelations(): RelationNode[];
+    gqlEnabled(): boolean;
 }

package/lib/parser/node/entityNode.js

@@ -8,10 +8,13 @@ export class EntityNode {
         this.fields = table.columns.map(column => FieldNode.fromColumn(column, table));
         this.relations = table
             .getReferenceColumns()
-            .map(it => RelationNode.fromReference(this, it, table.store
-            .table(it.data.reference.targetTable)
-            .column(it.data.reference.targetColumn)
-            .fieldName()));
+            .map(it => {
+            const targetTable = table.store
+                .table(it.data.reference.targetTable);
+            return RelationNode.fromReference(this, it, targetTable
+                .column(it.data.reference.targetColumn)
+                .fieldName(), targetTable.gqlOption);
+        });
     }
     field(fieldName) {
         return this.fields.find(it => it.fieldName === fieldName);
@@ -43,4 +46,7 @@ export class EntityNode {
     findReferencedRelations() {
         return this.repository.root.findReferencedRelations(this.entityName);
     }
+    gqlEnabled() {
+        return this.repository.gqlOption.enabled;
+    }
 }

package/lib/parser/node/gql/queryNode.d.ts

@@ -1,11 +1,13 @@
 import { ParameterNode } from '../parameterNode.js';
 import { TypeNode } from '../typeNode.js';
+export declare type ListQueryType = 'all' | 'paging';
 export declare class QueryNode {
     readonly queryName: string;
     readonly repoMethodName: string;
     readonly queryParams: ParameterNode[];
     readonly returnType: TypeNode;
     readonly isList: boolean;
-    constructor(queryName: string, repoMethodName: string, queryParams: ParameterNode[], returnType: TypeNode, isList: boolean);
+    readonly listType?: ListQueryType | undefined;
+    constructor(queryName: string, repoMethodName: string, queryParams: ParameterNode[], returnType: TypeNode, isList: boolean, listType?: ListQueryType | undefined);
     toGqlString(): string;
 }

package/lib/parser/node/gql/queryNode.js

@@ -1,11 +1,12 @@
 import { ParameterNode } from '../parameterNode.js';
 export class QueryNode {
-    constructor(queryName, repoMethodName, queryParams, returnType, isList) {
+    constructor(queryName, repoMethodName, queryParams, returnType, isList, listType) {
         this.queryName = queryName;
         this.repoMethodName = repoMethodName;
         this.queryParams = queryParams;
         this.returnType = returnType;
         this.isList = isList;
+        this.listType = listType;
     }
     toGqlString() {
         return `${this.queryName}${ParameterNode.parametersToGqlString(...this.queryParams)}: ${this.returnType.toGqlString()}`;

package/lib/parser/node/gql/typeDefNode.d.ts

@@ -5,5 +5,5 @@ export declare class TypeDefNode {
     readonly params: ParameterNode[];
     static new(entity: EntityNode): TypeDefNode;
     static deletedNode(entity: EntityNode): TypeDefNode;
-    constructor(typeName: string, params: ParameterNode[]);
+    private constructor();
 }

package/lib/parser/node/gql/typeDefNode.js

@@ -5,9 +5,10 @@ export class TypeDefNode {
         this.params = params;
     }
     static new(entity) {
-        const reference = entity.relations.map(rel => new ParameterNode(rel.refPropertyName(), rel.refType()));
+        const reference = entity.relations.filter(it => it.to.gqlOption.enabled).map(rel => new ParameterNode(rel.refPropertyName(), rel.refType()));
         const referencedBy = entity
             .findReferencedRelations()
+            .filter(it => it.from.gqlOption.enabled)
             .map(rel => new ParameterNode(rel.referencedByPropertyName(), rel.referenceByType()));
         return new TypeDefNode(entity.entityName.name, [
             ...entity.fields.map(it => it.toParam()),

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

@@ -3,20 +3,30 @@ import { EntityNode } from './entityNode.js';
 import { ReferenceColumn } from '../../migration/serializable/column.js';
 import { EntityName } from './entityName.js';
 import { Relation } from '../../migration/data/relation.js';
+import { GQLOption } from "../../migration/data/GQLOption.js";
+declare type From = {
+    field: string;
+    columnName: string;
+    gqlOption: GQLOption;
+};
+declare type To = {
+    field: string;
+    columnName: string;
+    tableName: string;
+    entityName: EntityName;
+    gqlOption: GQLOption;
+};
 export declare class RelationNode {
     readonly parent: EntityNode;
     readonly relationName: string | undefined;
-    readonly fromField: string;
-    readonly toField: string;
-    readonly toTableName: string;
-    readonly toEntityName: EntityName;
     readonly relation: Relation;
-    readonly fromColumnName: string;
-    readonly toColumnName: string;
-    static fromReference(entity: EntityNode, ref: ReferenceColumn, targetFieldName: string): RelationNode;
+    readonly from: From;
+    readonly to: To;
+    static fromReference(entity: EntityNode, ref: ReferenceColumn, targetFieldName: string, targetTableGqlOption: GQLOption): RelationNode;
     private constructor();
     refPropertyName(): string;
     referencedByPropertyName(): string;
     refType(): TypeNode;
     referenceByType(): TypeNode;
 }
+export {};

package/lib/parser/node/relationNode.js

@@ -2,28 +2,34 @@ 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, fromColumnName, toColumnName) {
+    constructor(parent, relationName, relation, from, to) {
         this.parent = parent;
         this.relationName = relationName;
-        this.fromField = fromField;
-        this.toField = toField;
-        this.toTableName = toTableName;
-        this.toEntityName = toEntityName;
         this.relation = relation;
-        this.fromColumnName = fromColumnName;
-        this.toColumnName = toColumnName;
+        this.from = from;
+        this.to = to;
     }
-    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, ref.data.columnName, ref.data.reference.targetColumn);
+    static fromReference(entity, ref, targetFieldName, targetTableGqlOption) {
+        return new RelationNode(entity, ref.data.reference.relationName, ref.data.reference.relation, {
+            field: ref.data.fieldName,
+            columnName: ref.data.columnName,
+            gqlOption: ref.table.gqlOption,
+        }, {
+            field: targetFieldName,
+            tableName: ref.data.reference.targetTable,
+            entityName: new EntityName(TableHandler.tableNameToEntityName(ref.data.reference.targetTable)),
+            columnName: ref.data.reference.targetColumn,
+            gqlOption: targetTableGqlOption,
+        });
     }
     refPropertyName() {
-        return this.relationName || this.fromField + this.toEntityName.name;
+        return this.relationName || this.from.field + this.to.entityName.name;
     }
     referencedByPropertyName() {
         return (this.relationName || '') + this.parent.entityName.name;
     }
     refType() {
-        return new EntityTypeNode(this.toEntityName, false, false);
+        return new EntityTypeNode(this.to.entityName, false, false);
     }
     referenceByType() {
         if (this.relation === 'Many')

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

@@ -5,6 +5,7 @@ import { QueryNode } from './gql/queryNode.js';
 import { MutationNode } from './gql/mutationNode.js';
 import { TableHandler } from '../../migration/serializable/table.js';
 import { EntityName } from './entityName.js';
+import { GQLOption } from "../../migration/data/GQLOption.js";
 export declare class RepositoryNode {
     readonly root: RootNode;
     readonly tableName: string;
@@ -14,6 +15,7 @@ export declare class RepositoryNode {
     readonly autoIncrementColumn?: string;
     readonly queries: QueryNode[];
     readonly mutations: MutationNode[];
+    readonly gqlOption: GQLOption;
     constructor(root: RootNode, table: TableHandler);
     private createEntity;
     getDefaultValueColumnNames(): string[];

package/lib/parser/node/repositoryNode.js

@@ -15,8 +15,9 @@ export class RepositoryNode {
         this.autoIncrementColumn = table.columns
             .find(it => it.serialize().autoIncrement)
             ?.fieldName();
-        this.queries = new QueryNodeFactory().create(table);
+        this.queries = new QueryNodeFactory().create(table, table.gqlOption);
         this.mutations = new MutationNodeFactory().create(table, this.entity);
+        this.gqlOption = table.gqlOption;
     }
     createEntity(table) {
         return new EntityNode(this, table);
@@ -37,14 +38,14 @@ export class RepositoryNode {
         };
         const refMethods = (relation) => {
             return new FindMethodNode([
-                new ParameterNode(relation.fromField, new EntityTypeNode(relation.parent.field(relation.fromField).dbType, false, false)),
+                new ParameterNode(relation.from.field, new EntityTypeNode(relation.parent.field(relation.from.field).dbType, false, false)),
             ], new EntityTypeNode(EntityName.fromTableName(relation.parent.repository.tableName), relation.relation === 'Many', false), false);
         };
         const referencedByMethod = (relation) => {
-            const to = relation.parent.repository.root.findRepository(relation.toEntityName);
+            const to = relation.parent.repository.root.findRepository(relation.to.entityName);
             return new FindMethodNode([
-                new ParameterNode(relation.toField, new EntityTypeNode(to.entity.field(relation.toField).dbType, false, false)),
-            ], new EntityTypeNode(relation.toEntityName, false, false), false);
+                new ParameterNode(relation.to.field, new EntityTypeNode(to.entity.field(relation.to.field).dbType, false, false)),
+            ], new EntityTypeNode(relation.to.entityName, false, false), false);
         };
         const methods = [
             new FindMethodNode(node.primaryKeys.map(it => {

package/lib/parser/node/rootNode.js

@@ -10,7 +10,7 @@ export class RootNode {
     }
     findReferencedRelations(entity) {
         return this.entities()
-            .map(it => it.relations.find(it => it.toEntityName.name === entity.name))
+            .map(it => it.relations.find(it => it.to.entityName.name === entity.name))
             .filter(it => it !== undefined);
     }
     entities() {

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

@@ -6,7 +6,7 @@ export declare abstract class TypeNode {
     readonly isArray: boolean;
     readonly isNullable: boolean;
     readonly isArrayNullable: boolean;
-    constructor(typeName: DBColumnTypes | EntityName, isArray: boolean, isNullable: boolean, isArrayNullable?: boolean);
+    protected constructor(typeName: DBColumnTypes | EntityName, isArray: boolean, isNullable: boolean, isArrayNullable?: boolean);
     abstract toTsType(): TsType;
     toGqlString(): string;
 }

package/lib/parser/node/typeNode.js

@@ -23,7 +23,7 @@ export class TypeNode {
 }
 export class ListQueryOptionTypeNode extends TypeNode {
     constructor() {
-        super(new EntityName(TypeDefGenerator.ListQueryOptionType), false, true);
+        super(new EntityName(TypeDefGenerator.ListQueryOptionType), false, false);
     }
     toTsType() {
         return tsg

package/lib/parser/nodeFactory/mutationNodeFactory.js

@@ -5,6 +5,8 @@ import { FindMethodNode } from '../node/findMethod.js';
 export class MutationNodeFactory {
     constructor() {
         this.create = (table, entity) => {
+            if (!table.gqlOption.enabled)
+                return [];
             const result = [];
             const options = table.gqlOption.mutation;
             if (options.create.enabled) {

package/lib/parser/nodeFactory/queryNodeFactory.d.ts

@@ -1,7 +1,8 @@
 import { QueryNode } from '../node/gql/queryNode.js';
 import { TableHandler } from '../../migration/serializable/table.js';
+import { GQLOption } from "../../migration/data/GQLOption.js";
 export declare class QueryNodeFactory {
-    create(table: TableHandler): QueryNode[];
+    create(table: TableHandler, gqlOption: GQLOption): QueryNode[];
     private listQuery;
     private primaryQuery;
 }

package/lib/parser/nodeFactory/queryNodeFactory.js

@@ -4,11 +4,20 @@ import { EntityTypeNode, ListQueryOptionTypeNode, } from '../node/typeNode.js';
 import { ParameterNode } from '../node/parameterNode.js';
 import { FindMethodNode } from '../node/findMethod.js';
 export class QueryNodeFactory {
-    create(table) {
-        return [this.primaryQuery(table), this.listQuery(table)];
+    create(table, gqlOption) {
+        if (!gqlOption.enabled)
+            return [];
+        const result = [];
+        if (gqlOption.query.find) {
+            result.push(this.primaryQuery(table));
+        }
+        if (gqlOption.query.list !== false) {
+            result.push(this.listQuery(table, gqlOption.query.list));
+        }
+        return result;
     }
-    listQuery(table) {
-        return new QueryNode(lowercaseFirstLetter(plural(table.getEntityName().name)), 'find', [new ParameterNode('option', new ListQueryOptionTypeNode())], new EntityTypeNode(table.getEntityName(), true, false), true);
+    listQuery(table, listQueryType) {
+        return new QueryNode(lowercaseFirstLetter(plural(table.getEntityName().name)), 'find', listQueryType === 'paging' ? [new ParameterNode('option', new ListQueryOptionTypeNode())] : [], new EntityTypeNode(table.getEntityName(), true, false), true, listQueryType);
     }
     primaryQuery(table) {
         const primaryKeys = table.primaryKey.map(it => table.column(it).fieldName());

package/lib/runtime/dsl/factory.d.ts

@@ -1,8 +1,8 @@
 import { BetweenExpression, BooleanValueExpression, ComparisonExpression, Field, Fn, InExpression, IsNullExpression, Join, JoinType, Literal, ParenthesisExpression, Query, QueryTable, Sort, SortDirection, Value } from './query/query.js';
 export declare const QExpr: {
     readonly conditions: {
-        and: (...expr: BooleanValueExpression[]) => BooleanValueExpression;
-        or: (...expr: BooleanValueExpression[]) => BooleanValueExpression;
+        and: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
+        or: (...expr: Array<BooleanValueExpression | undefined | null>) => BooleanValueExpression;
         eq: (left: Value, right: Value) => ComparisonExpression;
         neq: (left: Value, right: Value) => ComparisonExpression;
         gt: (left: Value, right: Value) => ComparisonExpression;

package/lib/runtime/dsl/factory.js

@@ -1,6 +1,7 @@
 import { QueryNodeKind, } from './query/query.js';
+import { nonNullable } from "../util.js";
 const compound = (expr, operator) => {
-    return expr.reduce((acc, current) => ({
+    return expr.filter(nonNullable).reduce((acc, current) => ({
         kind: QueryNodeKind.CompoundExpr,
         left: acc,
         operator: operator,

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

@@ -14,6 +14,7 @@ export declare enum QueryNodeKind {
     Literal = 11,
     Sort = 12
 }
+export declare type LockMode = 'FOR UPDATE' | 'FOR SHARE';
 export declare type Query = {
     select: Select;
     from: QueryTable;
@@ -21,6 +22,7 @@ export declare type Query = {
     sort?: Sort[];
     limit?: number;
     offset?: number;
+    lock?: LockMode;
 };
 declare type Select = SelectExpr[];
 export declare const NO_ALIAS: "__SASAT_NO_ALIAS";

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

@@ -2,6 +2,13 @@ import { Sql } from './nodeToSql.js';
 const getJoin = (from) => {
     return from.joins.flatMap(join => [join, ...getJoin(join.table)]);
 };
+const getLock = (lock) => {
+    if (!lock)
+        return '';
+    if (lock === 'FOR UPDATE')
+        return ' FOR UPDATE';
+    return ' FOR SHARE';
+};
 export const queryToSql = (query) => {
     const select = query.select.map(Sql.select).join(', ');
     const join = getJoin(query.from).map(Sql.join).join(' ');
@@ -18,5 +25,6 @@ export const queryToSql = (query) => {
         where +
         sort +
         limit +
-        offset);
+        offset +
+        getLock(query.lock));
 };

package/lib/runtime/sasatDBDatasource.d.ts

@@ -2,7 +2,7 @@ import { CommandResponse, RelationMap } from '../index.js';
 import { Fields } from './field.js';
 import { SQLExecutor, SqlValueType } from '../db/connectors/dbClient.js';
 import { TableInfo } from './dsl/query/createQueryResolveInfo.js';
-import { BooleanValueExpression, Sort } from './dsl/query/query.js';
+import { BooleanValueExpression, LockMode, Sort } from './dsl/query/query.js';
 export declare type EntityType = Record<string, SqlValueType>;
 export declare type EntityResult<Entity, Identifiable> = Identifiable & Partial<Entity>;
 interface Repository<Entity, Creatable, Identifiable> {
@@ -16,7 +16,14 @@ export declare type ListQueryOption = {
     order?: string;
     asc?: boolean;
 };
-export declare abstract class SasatDBDatasource<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields> implements Repository<Entity, Creatable, Identifiable> {
+export declare type QueryOptions = {
+    where?: BooleanValueExpression;
+    sort?: Sort[];
+    limit?: number;
+    offset?: number;
+    lock?: LockMode;
+};
+export declare abstract class SasatDBDatasource<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields, QueryResult extends Partial<Entity> & Identifiable> implements Repository<Entity, Creatable, Identifiable> {
     protected client: SQLExecutor;
     protected abstract relationMap: RelationMap;
     protected abstract tableInfo: TableInfo;
@@ -32,27 +39,14 @@ export declare abstract class SasatDBDatasource<Entity extends EntityType, Creat
     create(entity: Creatable): Promise<Entity>;
     update(entity: Identifiable & Partial<Entity>): Promise<CommandResponse>;
     delete(entity: Identifiable): Promise<CommandResponse>;
-    first(fields?: EntityFields, option?: {
-        where?: BooleanValueExpression;
-        sort?: Sort[];
-    }, context?: any): Promise<EntityResult<Entity, Identifiable> | null>;
-    find(fields?: EntityFields, options?: {
-        where?: BooleanValueExpression;
-        sort?: Sort[];
-        limit?: number;
-        offset?: number;
-    }, context?: unknown): Promise<EntityResult<Entity, Identifiable>[]>;
+    first(fields?: EntityFields, option?: Omit<QueryOptions, 'limit' | 'offset'>, context?: any): Promise<QueryResult | null>;
+    find(fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
     findPageable(paging: {
         numberOfItem: number;
         where?: BooleanValueExpression;
         offset?: number;
         sort?: Sort[];
-    }, fields?: EntityFields, options?: {
-        where?: BooleanValueExpression;
-        sort?: Sort[];
-        limit?: number;
-        offset?: number;
-    }, context?: unknown): Promise<EntityResult<Entity, Identifiable>[]>;
+    }, fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
     private executeQuery;
     private createIdentifiableExpression;
 }

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

@@ -1,15 +1,9 @@
-import { BooleanValueExpression, Query, Sort } from '../dsl/query/query.js';
+import { BooleanValueExpression, Query } 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;
-};
+import { ListQueryOption, QueryOptions } from '../sasatDBDatasource.js';
 export declare const createQuery: (baseTableName: string, fields: Fields, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: any) => Query;
 declare type PagingOption = ListQueryOption & {
     where?: BooleanValueExpression;

package/lib/runtime/sql/runQuery.js

@@ -12,8 +12,10 @@ export const createQuery = (baseTableName, fields, options, tableInfo, relationM
         table.tableAlias = tableAlias;
         tableCount++;
         const info = tableInfo[tableName];
-        select.push(...unique([...table.fields.filter(notTypeName), ...info.identifiableKeys])
-            .map(it => {
+        select.push(...unique([
+            ...table.fields.filter(notTypeName),
+            ...info.identifiableKeys,
+        ]).map(it => {
             const realName = info.columnMap[it] || it;
             return QExpr.field(tableAlias, realName, tableAlias + SELECT_ALIAS_SEPARATOR + it);
         }));
@@ -33,7 +35,9 @@ export const createQuery = (baseTableName, fields, options, tableInfo, relationM
 export const createPagingInnerQuery = (tableName, tableAlias, fields, option, tableInfo) => {
     const map = tableInfo[tableName].columnMap;
     return {
-        select: fields.fields.filter(notTypeName).map(it => QExpr.field(tableAlias, map[it])),
+        select: fields.fields
+            .filter(notTypeName)
+            .map(it => QExpr.field(tableAlias, map[it])),
         from: QExpr.table(tableName, [], tableAlias),
         limit: option.numberOfItem,
         offset: option.offset,

package/lib/runtime/util.d.ts

@@ -2,3 +2,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[];
+export declare const nonNullable: <T>(value: T) => value is NonNullable<T>;

package/lib/runtime/util.js

@@ -8,3 +8,4 @@ export const unique = (array) => {
     }
     return result;
 };
+export const nonNullable = (value) => value != null;

package/package.json

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