duenamodb/lib/expression.d.ts

Simple, strongly-typed helpers around the AWS SDK DynamoDB client.

import type { NativeAttributeValue } from "@aws-sdk/util-dynamodb";
import type { DynamoDBTypes, SK } from "./types";
export declare const expressionAttributeNameKey: (key: string) => string;
export declare const expressionAttributeValueKey: (key: string) => string;
export declare const expressionAttributeNames: (names: string[]) => Record<string, string> | undefined;
export declare const expressionAttributeValues: <Attributes extends DynamoDBTypes, Options extends FilterCondition<Attributes>>(options: Options) => Record<string, NativeAttributeValue> | undefined;
export declare const conditionExpression: <Attributes extends DynamoDBTypes, Options extends FilterCondition<Attributes>>(options: Options) => string | undefined;
type NotExpression<Value extends NativeAttributeValue> = {
    duenamoType: "not";
    value: Value;
};
export declare const NOT: <Value extends unknown>(value: Value) => NotExpression<Value>;
type InExpression<Value extends NativeAttributeValue> = {
    duenamoType: "in";
    value: Value[];
};
export declare const IN: <Value extends unknown>(...value: Value[]) => InExpression<Value>;
type AndExpression<Value extends NativeAttributeValue> = {
    duenamoType: "and";
    value: DuenamoExpression<Value>[];
};
export declare const AND: <Attribute extends unknown>(...value: DuenamoExpression<Attribute>[]) => AndExpression<Attribute>;
type DuenamoExpression<Value extends NativeAttributeValue> = NotExpression<Value> | InExpression<Value> | AndExpression<Value> | IsLessExpression<Value> | IsGreaterExpression<Value> | IsLessOrEqualExpression<Value> | IsGreaterOrEqualExpression<Value> | IsBetweenExpression<Value> | BeginsWithExpression<Value>;
export type FilterCondition<Attributes extends DynamoDBTypes> = {
    [Key in keyof Attributes]?: Attributes[Key] | NotExpression<Attributes[Key]> | InExpression<Attributes[Key]> | AndExpression<Attributes[Key]> | IsLessExpression<Attributes[Key]> | IsGreaterExpression<Attributes[Key]> | IsLessOrEqualExpression<Attributes[Key]> | IsGreaterOrEqualExpression<Attributes[Key]> | IsBetweenExpression<Attributes[Key]> | BeginsWithExpression<Attributes[Key]>;
};
export declare const createConditionExpression: <Attributes extends DynamoDBTypes, Options extends FilterCondition<Attributes>>(object: Options) => {
    attributeNames: Record<string, string> | undefined;
    attributeValues: Record<string, any> | undefined;
    expression: string | undefined;
};
type IsLessExpression<Value extends NativeAttributeValue> = {
    duenamoType: "is_less_than";
    value: Value;
};
export declare const IS_LESS_THAN: <Value extends unknown>(value: Value) => IsLessExpression<Value>;
type IsGreaterExpression<Value extends NativeAttributeValue> = {
    duenamoType: "is_greater_than";
    value: Value;
};
export declare const IS_GREATER_THAN: <Value extends unknown>(value: Value) => IsGreaterExpression<Value>;
type IsLessOrEqualExpression<Value extends NativeAttributeValue> = {
    duenamoType: "is_less_or_equal";
    value: Value;
};
export declare const IS_LESS_OR_EQUAL_THAN: <Value extends unknown>(value: Value) => IsLessOrEqualExpression<Value>;
type IsGreaterOrEqualExpression<Value extends NativeAttributeValue> = {
    duenamoType: "is_greater_or_equal";
    value: Value;
};
export declare const IS_GREATER_OR_EQUAL_THAN: <Value extends unknown>(value: Value) => IsGreaterOrEqualExpression<Value>;
type IsBetweenExpression<Value extends NativeAttributeValue> = {
    duenamoType: "is_between";
    value1: Value;
    value2: Value;
};
export declare const IS_BETWEEN: <Value extends unknown>(value1: Value, value2: Value) => IsBetweenExpression<Value>;
type BeginsWithExpression<Value extends NativeAttributeValue> = {
    duenamoType: "begins_with";
    value: Value;
};
export declare const BEGINS_WITH: <Value extends unknown>(value: Value) => BeginsWithExpression<Value>;
export type SortKeyCondition<TSK extends SK> = TSK extends number ? TSK | IsLessExpression<TSK> | IsGreaterExpression<TSK> | IsLessOrEqualExpression<TSK> | IsGreaterOrEqualExpression<TSK> | IsBetweenExpression<TSK> : TSK extends string ? TSK | BeginsWithExpression<TSK> : TSK;
export {};