sasat 0.18.0 → 0.18.2

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

@@ -1,5 +1,5 @@
 import { TsCode } from '../../abstruct/tsCode.js';
-import { TsType } from "./type.js";
+import { TsType } from './type.js';
 export declare class IntersectionType extends TsCode {
     private readonly types;
     constructor(...types: Array<TsType>);

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

@@ -20,7 +20,11 @@ export class GeneratedRepositoryGenerator {
     generate() {
         const node = this.node;
         const entityPath = Directory.entityPath(Directory.paths.generatedDataSource.db, node.entityName);
-        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())
+        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,7 +36,7 @@ export class GeneratedRepositoryGenerator {
                 .typeRef(node.entityName.identifiableInterfaceName())
                 .importFrom(entityPath),
             node.entityName.fieldTypeRef(Directory.paths.generatedDataSource.db),
-            tsg.typeRef('QueryResult')
+            tsg.typeRef('QueryResult'),
         ])).addImport(['BaseDBDataSource'], Directory.basePath(Directory.paths.generatedDataSource.db, 'baseDBDataSource')))
             .addProperty(...this.properties(node))
             .addMethod(this.getDefaultValueMethod(node), ...this.findMethods(node))).disableEsLint();
@@ -111,7 +115,8 @@ export class GeneratedRepositoryGenerator {
                 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.parameter('options?', it.returnType.isArray
+                    ? tsg.typeRef('QueryOptions').importFrom('sasat')
                     : tsg.typeRef('Omit', [
                         tsg.typeRef('QueryOptions').importFrom('sasat'),
                         tsg.typeRef('"offset" | "limit" | "sort"'),

package/lib/generator/ts/entityGenerator.js

@@ -9,22 +9,22 @@ export class EntityGenerator {
     }
     entity() {
         return tsg
-            .interface(this.node.entityName.name)
-            .extends(tsg.extends(tsg.typeRef('EntityType').importFrom('sasat')))
-            .addProperties(this.node.fields.map(it => it.toPropertySignature()))
+            .typeAlias(this.node.entityName.name, tsg.typeLiteral(this.node.fields.map(it => it.toPropertySignature())))
             .export();
     }
     creatable() {
+        const onCreateRequiredFields = this.node.onCreateRequiredFields();
         return tsg
-            .typeAlias(this.node.entityName.creatableInterface(), tsg.intersectionType(tsg.typeLiteral(this.node
-            .onCreateRequiredFields()
-            .map(it => it.toPropertySignature())), tsg.typeRef(this.node.entityName.name).partial()))
+            .typeAlias(this.node.entityName.creatableInterface(), onCreateRequiredFields.length === 0
+            ? tsg.typeRef(this.node.entityName.name).partial()
+            : tsg.intersectionType(tsg.typeLiteral(this.node
+                .onCreateRequiredFields()
+                .map(it => it.toPropertySignature())), tsg.typeRef(this.node.entityName.name).partial()))
             .export();
     }
     identifiable() {
         return tsg
-            .interface(this.node.entityName.identifiableInterfaceName())
-            .addProperties(this.node.identifiableFields().map(it => it.toPropertySignature()))
+            .typeAlias(this.node.entityName.identifiableInterfaceName(), tsg.typeLiteral(this.node.identifiableFields().map(it => it.toPropertySignature())))
             .export();
     }
 }

package/lib/generator/ts/fieldGenerator.js

@@ -6,20 +6,20 @@ export class FieldGenerator {
         return new TsFile(...root
             .entities()
             .map(it => tsg
-            .typeAlias(`${it.entityName}Fields`, tsg.intersectionType(tsg.typeRef('Fields').importFrom('sasat'), this.typeLiteral(it)))
+            .typeAlias(`${it.entityName}Fields`, tsg
+            .typeRef('Fields', [
+            it.entityName.getTypeReference(Directory.paths.generated),
+            this.typeLiteral(it),
+        ])
+            .importFrom('sasat'))
             .export())).disableEsLint();
     }
     typeLiteral(entity) {
         return tsg.typeLiteral([
-            tsg.propertySignature('fields', tsg.arrayType(tsg
-                .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.to.entityName}Fields`))),
-                ...entity
-                    .findReferencedRelations()
-                    .map(it => tsg.propertySignature(`${it.referencedByPropertyName()}?`, tsg.typeRef(`${it.parent.entityName}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/resolverGenerator.js

@@ -9,7 +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.filter(it => it.to.gqlOption.enabled).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))));
@@ -54,6 +56,9 @@ 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().filter(it => it.gqlEnabled()).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,10 @@ import { tsg } from '../code/factory.js';
 import { MutationNode } from '../../../parser/node/gql/mutationNode.js';
 export class TypeDefGenerator {
     generate(root) {
-        const typeDefs = root.entities().filter(it => it.gqlEnabled()).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.js

@@ -12,7 +12,9 @@ export class RelationMapGenerator {
             .export();
     }
     referencedRelationType(node) {
-        const type = tsg.intersectionType(tsg.typeRef('Partial', [node.parent.entityName.getTypeReference(Directory.paths.generated)]), node.parent.entityName.identifiableTypeReference(Directory.paths.generated));
+        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) {

package/lib/generator/ts/staticFiles.js

@@ -29,7 +29,7 @@ export abstract class BaseDBDataSource<
   Entity extends EntityType,
   Creatable,
   Identifiable,
-  EntityFields extends Fields,
+  EntityFields extends Fields<Entity>,
   QueryResult extends Partial<Entity> & Identifiable,
 > extends SasatDBDatasource<Entity, Creatable, Identifiable, EntityFields, QueryResult> {
   protected relationMap = relationMap;

package/lib/parser/node/entityNode.js

@@ -6,14 +6,9 @@ export class EntityNode {
         this.repository = repository;
         this.entityName = table.getEntityName();
         this.fields = table.columns.map(column => FieldNode.fromColumn(column, table));
-        this.relations = table
-            .getReferenceColumns()
-            .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);
+        this.relations = table.getReferenceColumns().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) {

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

@@ -5,7 +5,9 @@ export class TypeDefNode {
         this.params = params;
     }
     static new(entity) {
-        const reference = entity.relations.filter(it => it.to.gqlOption.enabled).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)

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

@@ -3,7 +3,7 @@ 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";
+import { GQLOption } from '../../migration/data/GQLOption.js';
 declare type From = {
     field: string;
     columnName: string;

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

@@ -5,7 +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";
+import { GQLOption } from '../../migration/data/GQLOption.js';
 export declare class RepositoryNode {
     readonly root: RootNode;
     readonly tableName: string;

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

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

package/lib/parser/nodeFactory/queryNodeFactory.js

@@ -1,6 +1,6 @@
 import { lowercaseFirstLetter, plural } from '../../util/stringUtil.js';
 import { QueryNode } from '../node/gql/queryNode.js';
-import { EntityTypeNode, ListQueryOptionTypeNode, } from '../node/typeNode.js';
+import { EntityTypeNode, ListQueryOptionTypeNode } from '../node/typeNode.js';
 import { ParameterNode } from '../node/parameterNode.js';
 import { FindMethodNode } from '../node/findMethod.js';
 export class QueryNodeFactory {
@@ -17,7 +17,9 @@ export class QueryNodeFactory {
         return result;
     }
     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);
+        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.js

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

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, context?: any) => BooleanValueExpression;
+    on: (parentTableAlias: string, childTableAlias: string, context?: unknown) => BooleanValueExpression;
     relation: 'One' | 'OneOrZero' | 'Many';
 };
 export declare type RelationMap = {
@@ -19,4 +19,4 @@ export declare type TableInfo = {
         };
     };
 };
-export declare const createQueryResolveInfo: (tableName: string, fields: Fields, map: RelationMap, tableInfo: TableInfo) => QueryResolveInfo;
+export declare const createQueryResolveInfo: (tableName: string, fields: Fields<unknown>, 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) => Pick<Query, 'select' | 'from'>;
-export declare const createPagingInnerQuery: (tableName: string, fields: Fields, len: number, offset: number) => Query;
+export declare const fieldToQuery: (tableName: string, fields: Fields<unknown>, map: RelationMap) => Pick<Query, 'select' | 'from'>;
+export declare const createPagingInnerQuery: (tableName: string, fields: Fields<unknown>, len: number, offset: number) => Query;

package/lib/runtime/field.d.ts

@@ -1,5 +1,5 @@
-export declare type Fields = {
-    fields: string[];
-    relations?: Record<string, Fields | undefined>;
+export declare type Fields<Entity, Relation = Record<string, unknown>> = {
+    fields: Array<keyof Entity & string>;
+    relations?: Relation;
     tableAlias?: string;
 };

package/lib/runtime/gqlResolveInfoToField.d.ts

@@ -1,3 +1,3 @@
 import { GraphQLResolveInfo } from 'graphql';
 import { Fields } from './field.js';
-export declare const gqlResolveInfoToField: (info: GraphQLResolveInfo) => Fields;
+export declare const gqlResolveInfoToField: (info: GraphQLResolveInfo) => Fields<unknown>;

package/lib/runtime/sasatDBDatasource.d.ts

@@ -23,7 +23,7 @@ export declare type QueryOptions = {
     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> {
+export declare abstract class SasatDBDatasource<Entity extends EntityType, Creatable, Identifiable, EntityFields extends Fields<Entity>, QueryResult extends Partial<Entity> & Identifiable> implements Repository<Entity, Creatable, Identifiable> {
     protected client: SQLExecutor;
     protected abstract relationMap: RelationMap;
     protected abstract tableInfo: TableInfo;
@@ -39,7 +39,7 @@ 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?: Omit<QueryOptions, 'limit' | 'offset'>, context?: any): Promise<QueryResult | null>;
+    first(fields?: EntityFields, option?: Omit<QueryOptions, 'limit' | 'offset'>, context?: unknown): Promise<QueryResult | null>;
     find(fields?: EntityFields, options?: QueryOptions, context?: unknown): Promise<QueryResult[]>;
     findPageable(paging: {
         numberOfItem: number;

package/lib/runtime/sasatDBDatasource.js

@@ -61,7 +61,7 @@ export class SasatDBDatasource {
     async findPageable(paging, fields = { fields: this.fields }, options, context) {
         const query = createPagingFieldQuery({
             baseTableName: this.tableName,
-            fields,
+            fields: fields,
             tableInfo: this.tableInfo,
             relationMap: this.relationMap,
             pagingOption: paging,

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

@@ -4,22 +4,22 @@ import { RelationMap, TableInfo } from '../dsl/query/createQueryResolveInfo.js';
 import { Fields } from '../field.js';
 import { QueryResolveInfo } from '../dsl/query/sql/hydrate.js';
 import { ListQueryOption, QueryOptions } from '../sasatDBDatasource.js';
-export declare const createQuery: (baseTableName: string, fields: Fields, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: any) => Query;
+export declare const createQuery: (baseTableName: string, fields: Fields<unknown>, options: QueryOptions | undefined, tableInfo: TableInfo, relationMap: RelationMap, context?: unknown) => 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 createPagingInnerQuery: (tableName: string, tableAlias: string, fields: Fields<unknown>, option: PagingOption, tableInfo: TableInfo) => Query;
 export declare const runQuery: (client: SQLExecutor, query: Query, resolveInfo: QueryResolveInfo) => Promise<unknown[]>;
 declare type CreatePagingFieldQueryArg = {
     baseTableName: string;
-    fields: Fields;
+    fields: Fields<unknown>;
     tableInfo: TableInfo;
     relationMap: RelationMap;
     queryOption?: QueryOptions;
     pagingOption: ListQueryOption & {
         where?: BooleanValueExpression;
     };
-    context?: any;
+    context?: unknown;
 };
 export declare const createPagingFieldQuery: ({ baseTableName, fields, queryOption, pagingOption, tableInfo, relationMap, context, }: CreatePagingFieldQueryArg) => Query;
 export {};

package/package.json

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