sasat 0.19.6 → 0.19.8

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

@@ -3,10 +3,11 @@ import { nonNullableFilter } from '../../../util/type.js';
 import { GQLString, makeGQLType } from './gqlString.js';
 import { typeFieldDefinitionToTsg } from './typeDefinition.js';
 import { EntityName } from '../../nodes/entityName.js';
+import { getArgs } from '../../../migration/data/GQLOption.js';
 export const generateTypeDefs = (root) => {
     const types = [
         ...root.entities.map(makeEntityType),
-        makeQuery(root.queries),
+        makeQuery(root),
         makeMutation(root.mutations),
         makeSubscription(root.subscriptions.filter(it => it.gqlEnabled)),
     ].filter(nonNullableFilter);
@@ -61,18 +62,29 @@ const makeUpdateInput = (node) => {
         return null;
     return makeInput(node.name.updateInputName(), node.updateInput.fields);
 };
-const makeQuery = (queries) => {
-    if (queries.length === 0)
+const makeQueryTypeDef = (entity, query) => {
+    const args = getArgs(query, entity);
+    return tsg.propertyAssign(query.type === 'primary' ? entity.primaryQueryName() : query.name, typeFieldDefinitionToTsg({
+        return: GQLString.type({
+            typeName: entity.name.name,
+            entity: true,
+            array: query.type === 'list-paging' || query.type === 'list-all',
+            nullable: query.type !== 'list-paging' && query.type !== 'list-all',
+        }),
+        args: args.map(it => ({
+            name: it.name,
+            type: it.type + '!',
+        })),
+    }));
+};
+const makeQueryProperties = (root) => {
+    return root.entities.flatMap(entity => entity.queries.map(it => makeQueryTypeDef(entity, it)));
+};
+const makeQuery = (root) => {
+    const properties = makeQueryProperties(root);
+    if (properties.length === 0)
         return null;
-    return tsg.propertyAssign('Query', tsg.object(...queries.map(query => {
-        return tsg.propertyAssign(query.queryName, typeFieldDefinitionToTsg({
-            return: GQLString.type(query.returnType),
-            args: query.args.map(arg => ({
-                name: arg.name,
-                type: GQLString.type(arg.type),
-            })),
-        }));
-    })));
+    return tsg.propertyAssign('Query', tsg.object(...properties));
 };
 const makeMutation = (mutations) => {
     if (mutations.length === 0)

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

@@ -3,9 +3,16 @@ import { columnTypeToTsType } from '../../../migration/column/columnTypes.js';
 import { makeTypeRef } from './scripts/getEntityTypeRefs.js';
 import { makeDatasource } from './scripts/makeDatasource.js';
 import { Directory } from '../../directory.js';
+import { nonNullable } from '../../../runtime/util.js';
+import { getArgs } from '../../../migration/data/GQLOption.js';
+import { toTsType } from '../../scripts/gqlTypes.js';
+import { makeQueryConditionExpr } from './scripts/makeQueryConditionExpr.js';
+const DIR = 'GENERATED';
 export const generateQueryResolver = (root) => {
     return new TsFile(tsg
-        .variable('const', 'query', tsg.object(...root.queries.map(makeQuery)))
+        .variable('const', 'query', tsg.object(...root.entities
+        .flatMap(entity => entity.queries.map(query => makeGQLQuery(entity, query)))
+        .filter(nonNullable)))
         .export()).disableEsLint();
 };
 const makeResolver = () => tsg.identifier('makeResolver').importFrom('sasat');
@@ -22,10 +29,72 @@ const makeQuery = (node) => {
         .toAsync())
         .typeArgs(tsg
         .typeRef('GQLContext')
-        .importFrom(Directory.resolve('GENERATED', 'BASE', 'context')), tsg.typeLiteral(node.args.map(it => tsg.propertySignature(it.name, tsg.typeRef(it.type.entity
+        .importFrom(Directory.resolve(DIR, 'BASE', 'context')), tsg.typeLiteral(node.args.map(it => tsg.propertySignature(it.name, tsg.typeRef(it.type.entity
         ? it.type.typeName
         : columnTypeToTsType(it.type.dbType)))))));
 };
+const pagingOption = {
+    kind: 'paging-option',
+    name: 'option',
+    type: 'PagingOption',
+};
+const makeGQLQuery = (entity, query) => {
+    const args = getArgs(query, entity);
+    return tsg.propertyAssign(query.type === 'primary' ? entity.name.lowerCase() : query.name, makeResolver()
+        .call(tsg
+        .arrowFunc([
+        tsg.parameter('_'),
+        tsg.parameter(`{${args.map(it => it.name).join(',')}}`),
+        tsg.parameter('context'),
+        tsg.parameter('info'),
+    ], undefined, makeGQLQueryBody(entity, query))
+        .toAsync())
+        .typeArgs(tsg
+        .typeRef('GQLContext')
+        .importFrom(Directory.resolve('GENERATED', 'BASE', 'context')), tsg.typeLiteral(args.map(it => tsg.propertySignature(it.name, it.type === 'PagingOption'
+        ? tsg.typeRef(it.type).importFrom('sasat')
+        : tsg.typeRef(toTsType(it.type)))))));
+};
+const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+const makeGQLQueryBody = (entity, query) => {
+    const fields = tsg.variable('const', 'fields', tsg
+        .identifier('gqlResolveInfoToField')
+        .importFrom('sasat')
+        .call(tsg.identifier('info'))
+        .as(makeTypeRef(entity.name, 'fields', 'GENERATED')));
+    const where = query.conditions && query.conditions.length !== 0
+        ? tsg.variable('const', 'where', qExpr
+            .property('conditions')
+            .property('and')
+            .call(...(query.conditions || []).map(makeQueryConditionExpr)))
+        : null;
+    const method = {
+        single: 'first',
+        primary: entity.primaryQueryName(),
+        'list-all': 'find',
+        'list-paging': 'findPageable',
+    };
+    const queryArgs = getArgs(query, entity);
+    const primaryArgs = query.type === 'primary'
+        ? queryArgs.map(it => tsg.identifier(it.name))
+        : [];
+    const args = [
+        ...primaryArgs,
+        query.type === 'list-paging'
+            ? tsg
+                .identifier('pagingOption')
+                .importFrom('sasat')
+                .call(tsg.identifier('option'))
+            : null,
+        tsg.identifier('fields'),
+        tsg.identifier(where ? '{ where }' : 'undefined'),
+        tsg.identifier('context'),
+    ].filter(nonNullable);
+    const result = makeDatasource(entity.name, DIR)
+        .property(method[query.type])
+        .call(...args);
+    return tsg.block(fields, where, tsg.return(result));
+};
 const makeQueryBody = (node) => {
     if (node.type === 'primary')
         return makePrimaryQuery(node);

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

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

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

@@ -0,0 +1,58 @@
+import typescript from 'typescript';
+import { unique } from '../../../runtime/util.js';
+import { TsFile, tsg } from '../../../tsg/index.js';
+import { ImportDeclaration as TsgImport } from '../../../tsg/importDeclaration.js';
+const { createSourceFile, ScriptTarget, SyntaxKind } = typescript;
+const isImported = (sourceFile, type, paths) => {
+    const importDeclarations = sourceFile.statements.filter(it => it.kind === SyntaxKind.ImportDeclaration);
+    return importDeclarations.some(it => {
+        if (!paths.includes(it.moduleSpecifier.getText(sourceFile)))
+            return false;
+        const binding = it.importClause?.namedBindings;
+        if (binding?.kind !== SyntaxKind.NamedImports)
+            return false;
+        return binding.elements.some(it => {
+            return it.name.text.trim() === type;
+        });
+    });
+};
+export const generateUserDefinedCondition = (root, content) => {
+    const sourceFile = createSourceFile('conditions.ts', content, ScriptTarget.ESNext);
+    sourceFile.getChildren().map(it => it);
+    const exportedVariables = sourceFile.statements.filter(it => it.kind === SyntaxKind.VariableStatement &&
+        it.modifiers?.some(it => it.kind === SyntaxKind.ExportKeyword));
+    const contextImported = isImported(sourceFile, 'GQLContext', [
+        '"./context"',
+        '"./context.js"',
+    ]);
+    const customConditionImported = isImported(sourceFile, 'CustomCondition', [
+        '"sasat"',
+    ]);
+    const customConditionNames = unique(root.entities.flatMap(it => [
+        ...it.references.flatMap(it => it.joinCondition
+            .filter(it => it.kind === 'custom')
+            .map(it => it.conditionName)),
+        ...it.referencedBy.flatMap(it => it.joinCondition
+            .filter(it => it.kind === 'custom')
+            .map(it => it.conditionName)),
+    ]));
+    const statements = [];
+    customConditionNames.forEach(conditionName => {
+        const exists = exportedVariables.some(it => {
+            return (it.declarationList.declarations[0].name.getText(sourceFile) ===
+                conditionName);
+        });
+        if (!exists) {
+            statements.push(tsg
+                .variable('const', conditionName, tsg.arrowFunc([], undefined, tsg.block(tsg.throw(tsg.new(tsg.identifier('Error'), tsg.string('TODO: Not Implemented'))))), tsg.typeRef('CustomCondition', [tsg.typeRef('GQLContext')]))
+                .export());
+        }
+    });
+    const context = contextImported
+        ? ''
+        : new TsgImport(['GQLContext'], './context').toString() + '\n';
+    const condition = customConditionImported
+        ? ''
+        : new TsgImport(['CustomCondition'], 'sasat').toString() + '\n';
+    return (context + condition + content + '\n' + new TsFile(...statements).toString());
+};

package/lib/generatorv2/codegen/ts/relationMap/getRequiredColumnNames.d.ts

@@ -1,3 +1,2 @@
 import { ReferencedNode, ReferenceNode } from '../../../nodes/entityNode.js';
-export declare const getParentRequiredFieldNames: (ref: ReferenceNode | ReferencedNode) => string[];
 export declare const getChildRequiredNames: (ref: ReferencedNode | ReferenceNode) => string[];

package/lib/generatorv2/codegen/ts/relationMap/getRequiredColumnNames.js

@@ -1,33 +1,25 @@
 import { nonNullable } from '../../../../runtime/util.js';
-const getParentConditionValue = cv => {
-    if (cv.type === 'parent') {
-        return cv.field;
-    }
-    return null;
-};
 const getChildConditionValue = cv => {
-    if (cv.type === 'child') {
+    if (cv.kind === 'child') {
         return cv.field;
     }
     return null;
 };
-const getConditionParentColumnNames = (getConditionValue) => (c) => {
+const getConditionChildColumnNames = (getConditionValue) => (c) => {
+    if (c.kind === 'custom')
+        return c.childRequiredFields || [];
     const result = [getConditionValue(c.left)];
     if (c.operator !== 'BETWEEN') {
         result.push(getConditionValue(c.right));
     }
     else {
-        if (c.right.type === 'range') {
+        if (c.right.kind === 'range') {
             result.push(getConditionValue(c.right.begin), getConditionValue(c.right.end));
         }
     }
     return result;
 };
-export const getParentRequiredFieldNames = (ref) => {
-    const getNames = getConditionParentColumnNames(getParentConditionValue);
-    return ref.joinCondition.flatMap(getNames).filter(nonNullable);
-};
 export const getChildRequiredNames = (ref) => {
-    const getNames = getConditionParentColumnNames(getChildConditionValue);
+    const getNames = getConditionChildColumnNames(getChildConditionValue);
     return ref.joinCondition.flatMap(getNames).filter(nonNullable);
 };

package/lib/generatorv2/codegen/ts/relationMap/index.js

@@ -1,15 +1,15 @@
 import { TsFile, tsg } from '../../../../tsg/index.js';
 import { EntityName } from '../../../nodes/entityName.js';
 import { makeContextTypeRef, makeTypeRef, } from './../scripts/getEntityTypeRefs.js';
-import { makeCondition } from './makeCondition.js';
-import { getChildRequiredNames, } from './getRequiredColumnNames.js';
+import { makeJoinConditionValue } from './makeJoinConditionValue.js';
+import { getChildRequiredNames } from './getRequiredColumnNames.js';
 import { nonNullable } from '../../../../runtime/util.js';
 export const generateRelationMap = (root) => {
     return new TsFile(makeRelationMap(root), makeTableInfo(root), ...root.entities.flatMap(entityRelationType)).disableEsLint();
 };
 const makeRelationMap = (root) => {
     return tsg
-        .variable('const', tsg.identifier('relationMap'), tsg.object(...root.entities.map(it => makeEntityRelationMap(it, root))), tsg
+        .variable('const', tsg.identifier('relationMap'), tsg.object(...root.entities.map(it => makeEntityRelationMap(it))), tsg
         .typeRef('RelationMap', [makeContextTypeRef('GENERATED')])
         .importFrom('sasat'))
         .export();
@@ -22,19 +22,17 @@ const fieldNameToColumnNameAndFilterPrimary = (node) => (field) => {
         return null;
     return column.columnName;
 };
-const makeEntityRelationMap = (node, root) => {
+const makeEntityRelationMap = (node) => {
     return tsg.propertyAssign(node.tableName, tsg.object(...node.references.map(ref => {
         const toColumnName = fieldNameToColumnNameAndFilterPrimary(ref.entity);
-        return tsg.propertyAssign(ref.fieldName, tsg.object(tsg.propertyAssign('table', tsg.string(ref.parentTableName)), makeCondition(node, ref), tsg.propertyAssign('array', tsg.boolean(ref.isArray)), tsg.propertyAssign('nullable', tsg.boolean(ref.isNullable)), tsg.propertyAssign('requiredColumns', tsg.array(getChildRequiredNames(ref)
+        return tsg.propertyAssign(ref.fieldName, tsg.object(tsg.propertyAssign('table', tsg.string(ref.parentTableName)), makeJoinConditionValue(node, ref), tsg.propertyAssign('array', tsg.boolean(ref.isArray)), tsg.propertyAssign('nullable', tsg.boolean(ref.isNullable)), tsg.propertyAssign('requiredColumns', tsg.array(getChildRequiredNames(ref)
             .map(toColumnName)
             .filter(nonNullable)
             .map(tsg.string)))));
     }), ...node.referencedBy.map(rel => {
-        const parentEntity = root.entities.find(it => it.tableName === rel.childTable);
-        const toColumnName = fieldNameToColumnNameAndFilterPrimary(parentEntity);
-        const toColumnName2 = fieldNameToColumnNameAndFilterPrimary(rel.entity);
-        return tsg.propertyAssign(rel.fieldName, tsg.object(tsg.propertyAssign('table', tsg.string(rel.childTable)), makeCondition(node, rel), tsg.propertyAssign('array', tsg.boolean(rel.isArray)), tsg.propertyAssign('nullable', tsg.boolean(rel.isNullable)), tsg.propertyAssign('requiredColumns', tsg.array(getChildRequiredNames(rel)
-            .map(toColumnName2)
+        const toColumnName = fieldNameToColumnNameAndFilterPrimary(rel.entity);
+        return tsg.propertyAssign(rel.fieldName, tsg.object(tsg.propertyAssign('table', tsg.string(rel.childTable)), makeJoinConditionValue(node, rel), tsg.propertyAssign('array', tsg.boolean(rel.isArray)), tsg.propertyAssign('nullable', tsg.boolean(rel.isNullable)), tsg.propertyAssign('requiredColumns', tsg.array(getChildRequiredNames(rel)
+            .map(toColumnName)
             .filter(nonNullable)
             .map(tsg.string)))));
     })));

package/lib/generatorv2/codegen/ts/relationMap/makeCondition.js

@@ -7,7 +7,7 @@ const qExpr = tsg.identifier('QExpr').importFrom('sasat');
 const makeConditionValueQExpr = (node, cv) => {
     const arg = tsg.identifier('arg');
     const context = arg.property('context?');
-    switch (cv.type) {
+    switch (cv.kind) {
         case 'context': {
             const value = context.property(cv.field);
             if (cv.onNotDefined.action !== 'defaultValue') {
@@ -45,7 +45,7 @@ const makeConditionValueQExpr = (node, cv) => {
         case 'today': {
             return qExpr
                 .property('value')
-                .call(tsg.identifier('getTodayDateString').importFrom('sasat').call());
+                .call(tsg.identifier('getTodayDateTimeString').importFrom('sasat').call());
         }
         case 'now': {
             return qExpr.property('value').call(tsg
@@ -56,7 +56,7 @@ const makeConditionValueQExpr = (node, cv) => {
     }
 };
 const makeRangeCondition = (entity, range) => {
-    if (range.type === 'range') {
+    if (range.kind === 'range') {
         return [
             makeConditionValueQExpr(entity, range.begin),
             makeConditionValueQExpr(entity, range.end),
@@ -72,6 +72,12 @@ const makeRangeCondition = (entity, range) => {
     ];
 };
 const makeConditionExpr = (entity, condition) => {
+    if (condition.kind === 'custom') {
+        return tsg
+            .identifier(condition.conditionName)
+            .importFrom('../conditions')
+            .call(tsg.identifier('arg'));
+    }
     if (condition.operator === 'BETWEEN') {
         return qExpr
             .property('conditions')

package/lib/generatorv2/codegen/ts/relationMap/makeJoinConditionValue.d.ts

@@ -0,0 +1,5 @@
+import { EntityNode, ReferencedNode, ReferenceNode } from '../../../nodes/entityNode.js';
+import { JoinConditionValue } from '../../../nodes/JoinConditionNode.js';
+import { TsExpression } from '../../../../tsg/index.js';
+export declare const makeJoinConditionValueQExpr: (node: EntityNode, cv: JoinConditionValue) => TsExpression;
+export declare const makeJoinConditionValue: (node: EntityNode, ref: ReferenceNode | ReferencedNode) => import("../../../../tsg/index.js").PropertyAssignment;

package/lib/generatorv2/codegen/ts/relationMap/makeJoinConditionValue.js

@@ -0,0 +1,73 @@
+import { tsg } from '../../../../tsg/index.js';
+import { makeThrowExpressions } from './makeNoContexError.js';
+import { nonNullableFilter } from '../../../../util/type.js';
+import { makeConditionValueQExpr } from '../scripts/makeConditonValueExpr.js';
+const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+const parentTableAlias = 'parentTableAlias';
+const childTableAlias = 'childTableAlias';
+export const makeJoinConditionValueQExpr = (node, cv) => {
+    const arg = tsg.identifier('arg');
+    switch (cv.kind) {
+        case 'parent': {
+            const columnName = node.fields.find(it => it.fieldName === cv.field)?.columnName ||
+                cv.field;
+            return qExpr
+                .property('field')
+                .call(arg.property(childTableAlias), tsg.string(columnName));
+        }
+        case 'child': {
+            const columnName = node.fields.find(it => it.fieldName === cv.field)?.columnName ||
+                cv.field;
+            return tsg.ternary(arg.property(parentTableAlias), qExpr
+                .property('field')
+                .call(arg.property(parentTableAlias), tsg.string(columnName)), qExpr
+                .property('value')
+                .call(arg.property('parent?').property(cv.field)));
+        }
+        default:
+            return makeConditionValueQExpr(cv);
+    }
+};
+const makeRangeCondition = (entity, range) => {
+    if (range.kind === 'range') {
+        return [
+            makeJoinConditionValueQExpr(entity, range.begin),
+            makeJoinConditionValueQExpr(entity, range.end),
+        ];
+    }
+    return [
+        tsg.spread(tsg
+            .identifier('getDayRangeQExpr')
+            .importFrom('sasat')
+            .call(tsg.new(tsg.identifier('Date')), range.thresholdHour
+            ? tsg.number(range.thresholdHour)
+            : tsg.identifier('undefined'))),
+    ];
+};
+const makeConditionExpr = (entity, condition) => {
+    if (condition.kind === 'custom') {
+        return tsg
+            .identifier(condition.conditionName)
+            .importFrom('../conditions')
+            .call(tsg.identifier('arg'));
+    }
+    if (condition.operator === 'BETWEEN') {
+        return qExpr
+            .property('conditions')
+            .property('between')
+            .call(makeJoinConditionValueQExpr(entity, condition.left), ...makeRangeCondition(entity, condition.right));
+    }
+    return qExpr
+        .property('conditions')
+        .property('comparison')
+        .call(makeJoinConditionValueQExpr(entity, condition.left), tsg.string(condition.operator), makeJoinConditionValueQExpr(entity, condition.right));
+};
+export const makeJoinConditionValue = (node, ref) => {
+    const arg = tsg.identifier('arg');
+    return tsg.propertyAssign('condition', tsg.arrowFunc([tsg.parameter(arg.toString())], tsg.typeRef('BooleanValueExpression').importFrom('sasat'), tsg.block(...ref.joinCondition
+        .flatMap(it => makeThrowExpressions(it))
+        .filter(nonNullableFilter), tsg.return(qExpr
+        .property('conditions')
+        .property('and')
+        .call(...ref.joinCondition.map(it => makeConditionExpr(node, it)))))));
+};

package/lib/generatorv2/codegen/ts/relationMap/makeNoContexError.d.ts

@@ -1,3 +1,3 @@
-import { ConditionNode } from '../../../nodes/ConditionNode.js';
+import { JoinConditionNode } from '../../../nodes/JoinConditionNode.js';
 import { IfStatement } from '../../../../tsg/index.js';
-export declare const makeThrowExpressions: (condition: ConditionNode) => (IfStatement | null)[];
+export declare const makeThrowExpressions: (condition: JoinConditionNode) => (IfStatement | null)[];

package/lib/generatorv2/codegen/ts/relationMap/makeNoContexError.js

@@ -1,27 +1,29 @@
 import { tsg } from '../../../../tsg/index.js';
 const makeJoinRangeConditionThrowExpressions = (cv) => {
-    if (cv.type === 'range') {
+    if (cv.kind === 'range') {
         const result = [];
-        if (cv.begin.type === 'context')
+        if (cv.begin.kind === 'context')
             result.push(makeJoinConditionThrowExpressions(cv.begin));
-        if (cv.end.type === 'context')
+        if (cv.end.kind === 'context')
             result.push(makeJoinConditionThrowExpressions(cv.end));
         return result;
     }
     return [];
 };
 const makeJoinConditionThrowExpressions = (cv) => {
-    if (cv.type !== 'context')
+    if (cv.kind !== 'context')
         return null;
     if (cv.onNotDefined.action !== 'error')
         return null;
     return tsg.if(tsg.binary(tsg.identifier('!arg.context'), '||', tsg.binary(tsg.identifier('arg.context').property(cv.field), '===', tsg.identifier('undefined'))), tsg.throw(tsg.new(tsg.identifier('Error'), tsg.string(cv.onNotDefined.message))));
 };
 export const makeThrowExpressions = (condition) => {
+    if (condition.kind === 'custom')
+        return [];
     if (condition.operator === 'BETWEEN') {
         return [
             makeJoinConditionThrowExpressions(condition.left),
-            ...(condition.right.type === 'range'
+            ...(condition.right.kind === 'range'
                 ? makeJoinRangeConditionThrowExpressions(condition.right)
                 : []),
         ];

package/lib/generatorv2/codegen/ts/scripts/makeConditonValueExpr.d.ts

@@ -0,0 +1,3 @@
+import { TsExpression } from '../../../../tsg/index.js';
+import { QueryConditionValue } from '../../../nodes/QueryConditionNode.js';
+export declare const makeConditionValueQExpr: (cv: QueryConditionValue) => TsExpression;

package/lib/generatorv2/codegen/ts/scripts/makeConditonValueExpr.js

@@ -0,0 +1,48 @@
+import { tsg } from '../../../../tsg/index.js';
+const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+export const makeConditionValueQExpr = (cv) => {
+    const arg = tsg.identifier('arg');
+    const context = arg.property('context?');
+    switch (cv.kind) {
+        case 'context': {
+            const value = context.property(cv.field);
+            if (cv.onNotDefined.action !== 'defaultValue') {
+                return qExpr.property('value').call(value);
+            }
+            return qExpr
+                .property('value')
+                .call(tsg.binary(context.property(cv.field), '||', typeof cv.onNotDefined.value === 'string'
+                ? tsg.string(cv.onNotDefined.value)
+                : tsg.number(cv.onNotDefined.value)));
+        }
+        case 'fixed': {
+            return qExpr
+                .property('value')
+                .call(typeof cv.value === 'string'
+                ? tsg.string(cv.value)
+                : tsg.number(cv.value));
+        }
+        case 'today': {
+            return qExpr.property('value').call(tsg
+                .identifier(cv.type === 'datetime'
+                ? 'getTodayDateTimeString'
+                : 'getTodayDateString')
+                .importFrom('sasat')
+                .call());
+        }
+        case 'now': {
+            return qExpr.property('value').call(tsg
+                .identifier('dateString')
+                .importFrom('sasat')
+                .call(tsg.new(tsg.identifier('Date'))));
+        }
+        case 'arg': {
+            return qExpr.property('value').call(tsg.identifier(cv.name));
+        }
+        case 'field': {
+            return qExpr
+                .property('field')
+                .call(tsg.string('t0'), tsg.string(cv.column));
+        }
+    }
+};

package/lib/generatorv2/codegen/ts/scripts/makeQueryConditionExpr.d.ts

@@ -0,0 +1,2 @@
+import { QueryConditionNode } from '../../../nodes/QueryConditionNode.js';
+export declare const makeQueryConditionExpr: (condition: QueryConditionNode) => import("../../../../tsg/index.js").CallExpression;

package/lib/generatorv2/codegen/ts/scripts/makeQueryConditionExpr.js

@@ -0,0 +1,15 @@
+import { tsg } from '../../../../tsg/index.js';
+import { makeConditionValueQExpr } from './makeConditonValueExpr.js';
+const qExpr = tsg.identifier('QExpr').importFrom('sasat');
+export const makeQueryConditionExpr = (condition) => {
+    if (condition.kind === 'between') {
+        return qExpr
+            .property('conditions')
+            .property('between')
+            .call(makeConditionValueQExpr(condition.left), makeConditionValueQExpr(condition.begin), makeConditionValueQExpr(condition.end));
+    }
+    return qExpr
+        .property('conditions')
+        .property('comparison')
+        .call(makeConditionValueQExpr(condition.left), tsg.string(condition.operator), makeConditionValueQExpr(condition.right));
+};

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

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

package/lib/generatorv2/codegen/tscodegen_v2.js

@@ -10,6 +10,7 @@ import { generateDatasource } from './ts/generateDatasource.js';
 import { generateResolver } from './ts/generateResolver.js';
 import { generateContext } from './ts/generateContext.js';
 import { generateSubscription } from './ts/generateSubscription.js';
+import { generateUserDefinedCondition } from './ts/generateUserDefinedCondition.js';
 export class TsCodegen_v2 {
     constructor() {
         this.fileExtension = 'ts';
@@ -34,5 +35,8 @@ export class TsCodegen_v2 {
         this.generateOnceFiles = () => {
             return staticFiles;
         };
+        this.generateConditions = (root, currentFile) => {
+            return generateUserDefinedCondition(root, currentFile);
+        };
     }
 }

package/lib/generatorv2/codegen_v2.d.ts

@@ -17,4 +17,5 @@ export declare class CodeGen_v2 {
     private generateGql;
     private generateFiles;
     private generateOnceFiles;
+    private generateCondition;
 }

package/lib/generatorv2/codegen_v2.js

@@ -5,6 +5,7 @@ import { mkDirIfNotExist, writeFileIfNotExist } from '../util/fsUtil.js';
 import { TsCodegen_v2 } from './codegen/tscodegen_v2.js';
 import { parse } from './parse.js';
 import { Directory } from './directory.js';
+import { readFileSync, writeFileSync } from 'fs';
 const { emptyDir, writeFile } = fs;
 export class CodeGen_v2 {
     constructor(store) {
@@ -25,6 +26,7 @@ export class CodeGen_v2 {
             ...this.generateGql(this.root),
             ...this.generateFiles(this.root),
             ...this.generateOnceFiles(),
+            this.generateCondition(this.root),
         ]);
     }
     async prepareDirs() {
@@ -66,4 +68,10 @@ export class CodeGen_v2 {
             .generateOnceFiles()
             .map(it => writeFileIfNotExist(this.getFullPath(this.outDir, it.name), it.body));
     }
+    async generateCondition(rootNode) {
+        const filePath = this.getFullPath(this.outDir, 'conditions');
+        await writeFileIfNotExist(filePath, '');
+        const content = readFileSync(filePath).toString();
+        writeFileSync(filePath, this.codeGen.generateConditions(rootNode, content));
+    }
 }