betterddb 0.6.7 → 0.6.9

package/src/builders/query-builder.ts

@@ -1,196 +0,0 @@
-import { QueryCommand, QueryCommandInput } from "@aws-sdk/lib-dynamodb";
-import { BetterDDB, GSIConfig } from "../betterddb";
-import { getOperatorExpression, Operator } from "../operator";
-import { PaginatedResult } from "../types/paginated-result";
-
-export class QueryBuilder<T> {
-  private keyConditions: string[] = [];
-  private filterConditions: string[] = [];
-  private expressionAttributeNames: Record<string, string> = {};
-  private expressionAttributeValues: Record<string, any> = {};
-  private index?: GSIConfig<T>;
-  private limit?: number;
-  private lastKey?: Record<string, any>;
-  private ascending: boolean = true;
-
-  constructor(
-    private parent: BetterDDB<T>,
-    private key: Partial<T>,
-  ) {
-    const keys = this.parent.getKeys();
-    let pkName = keys.primary.name;
-    let builtKey = this.parent.buildKey(this.key) as Record<string, any>;
-
-    this.expressionAttributeNames["#pk"] = pkName;
-    this.expressionAttributeValues[":pk_value"] = builtKey[pkName];
-  }
-
-  public usingIndex(indexName: string): this {
-    if (!this.parent.getKeys().gsis) {
-      throw new Error("No global secondary indexes defined for this table");
-    }
-    if (!(indexName in this.parent.getKeys().gsis!)) {
-      throw new Error("index does not exist");
-    }
-
-    this.index = this.parent.getKeys().gsis![indexName];
-
-    const pkName = this.index!.primary.name;
-    const builtKey = this.parent.buildIndexes(this.key);
-    this.expressionAttributeNames["#pk"] = pkName;
-    this.expressionAttributeValues[":pk_value"] = builtKey[pkName];
-
-    return this;
-  }
-
-  public sortAscending(): this {
-    this.ascending = true;
-    return this;
-  }
-
-  public sortDescending(): this {
-    this.ascending = false;
-    return this;
-  }
-
-  public where(
-    operator: Operator,
-    values: Partial<T> | [Partial<T>, Partial<T>],
-  ): this {
-    const keys = this.parent.getKeys();
-    // Determine the sort key name from either the index or the primary keys.
-    const sortKeyName = this.index ? this.index.sort?.name : keys.sort?.name;
-    if (!sortKeyName) {
-      throw new Error("Sort key is not defined for this table/index.");
-    }
-    const nameKey = "#sk";
-    this.expressionAttributeNames[nameKey] = sortKeyName;
-
-    // Enforce that a complex sort key requires an object input.
-    if (typeof values !== "object" || values === null) {
-      throw new Error(
-        `For complex sort keys, please provide an object with all necessary properties.`,
-      );
-    }
-
-    if (operator === "between") {
-      if (!Array.isArray(values) || values.length !== 2) {
-        throw new Error(
-          `For 'between' operator, values must be a tuple of two objects`,
-        );
-      }
-      const valueKeyStart = ":sk_start";
-      const valueKeyEnd = ":sk_end";
-      // Use the key definition's build function to build the key from the full object.
-      this.expressionAttributeValues[valueKeyStart] = this.index
-        ? this.parent.buildIndexes(values[0])[sortKeyName]
-        : this.parent.buildKey(values[0])[sortKeyName];
-      this.expressionAttributeValues[valueKeyEnd] = this.index
-        ? this.parent.buildIndexes(values[1])[sortKeyName]
-        : this.parent.buildKey(values[1])[sortKeyName];
-      this.keyConditions.push(
-        `${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`,
-      );
-    } else if (operator === "begins_with") {
-      const valueKey = ":sk_value";
-      this.expressionAttributeValues[valueKey] = this.index
-        ? this.parent.buildIndexes(values as Partial<T>)[sortKeyName]
-        : this.parent.buildKey(values as Partial<T>)[sortKeyName];
-      this.keyConditions.push(`begins_with(${nameKey}, ${valueKey})`);
-    } else {
-      // For eq, lt, lte, gt, gte:
-      const valueKey = ":sk_value";
-      this.expressionAttributeValues[valueKey] = this.index
-        ? this.parent.buildIndexes(values as Partial<T>)[sortKeyName]
-        : this.parent.buildKey(values as Partial<T>)[sortKeyName];
-      const condition = getOperatorExpression(operator, nameKey, valueKey);
-      this.keyConditions.push(condition);
-    }
-    return this;
-  }
-
-  public filter(
-    attribute: keyof T,
-    operator: Operator,
-    values: any | [any, any],
-  ): this {
-    const attrStr = String(attribute);
-    const randomString = Math.random().toString(36).substring(2, 15);
-    const placeholderName = `#attr_${attrStr}_${randomString}`;
-    this.expressionAttributeNames[placeholderName] = attrStr;
-    if (operator === "between") {
-      if (!Array.isArray(values) || values.length !== 2) {
-        throw new Error(
-          "For 'between' operator, values must be a tuple of two items",
-        );
-      }
-      const placeholderValueStart = `:val_start_${attrStr}_${randomString}`;
-      const placeholderValueEnd = `:val_end_${attrStr}_${randomString}`;
-      this.expressionAttributeValues[placeholderValueStart] = values[0];
-      this.expressionAttributeValues[placeholderValueEnd] = values[1];
-      this.filterConditions.push(
-        `${placeholderName} BETWEEN ${placeholderValueStart} AND ${placeholderValueEnd}`,
-      );
-    } else if (operator === "begins_with" || operator === "contains") {
-      const placeholderValue = `:val_${attrStr}_${randomString}`;
-      this.expressionAttributeValues[placeholderValue] = values;
-      this.filterConditions.push(
-        `${operator}(${placeholderName}, ${placeholderValue})`,
-      );
-    } else {
-      const placeholderValue = `:val_${attrStr}_${randomString}`;
-      this.expressionAttributeValues[placeholderValue] = values;
-      const condition = getOperatorExpression(
-        operator,
-        placeholderName,
-        placeholderValue,
-      );
-      this.filterConditions.push(condition);
-    }
-
-    return this;
-  }
-
-  public limitResults(limit: number): this {
-    this.limit = limit;
-    return this;
-  }
-
-  public startFrom(lastKey: Record<string, any>): this {
-    this.lastKey = lastKey;
-    return this;
-  }
-
-  /**
-   * Executes the query and returns a Promise that resolves with an array of items.
-   */
-  public async execute(): Promise<PaginatedResult<T>> {
-    this.keyConditions.unshift(`#pk = :pk_value`);
-    const keyConditionExpression = this.keyConditions.join(" AND ");
-
-    const params: QueryCommandInput = {
-      TableName: this.parent.getTableName(),
-      KeyConditionExpression: keyConditionExpression,
-      ExpressionAttributeNames: this.expressionAttributeNames,
-      ExpressionAttributeValues: this.expressionAttributeValues,
-      ScanIndexForward: this.ascending,
-      Limit: this.limit,
-      ExclusiveStartKey: this.lastKey,
-      IndexName: this.index?.name ?? undefined,
-    };
-
-    if (this.parent.getEntityType()) {
-      this.filterConditions.push(`#entity = :entity_value`);
-      this.expressionAttributeNames["#entity"] = "entityType";
-      this.expressionAttributeValues[":entity_value"] =
-        this.parent.getEntityType();
-    }
-    params.FilterExpression = this.filterConditions.join(" AND ");
-
-    const result = await this.parent.getClient().send(new QueryCommand(params));
-    return {
-      items: this.parent.getSchema().array().parse(result.Items) as T[],
-      lastKey: result.LastEvaluatedKey ?? undefined,
-    };
-  }
-}

package/src/builders/scan-builder.ts

@@ -1,87 +0,0 @@
-import { ScanCommand, ScanCommandInput } from "@aws-sdk/lib-dynamodb";
-import { BetterDDB } from "../betterddb";
-import { getOperatorExpression, Operator } from "../operator";
-import { PaginatedResult } from "../types/paginated-result";
-
-export class ScanBuilder<T> {
-  private filters: string[] = [];
-  private expressionAttributeNames: Record<string, string> = {};
-  private expressionAttributeValues: Record<string, any> = {};
-  private limit?: number;
-  private lastKey?: Record<string, any>;
-
-  constructor(private parent: BetterDDB<T>) {}
-
-  public where(
-    attribute: keyof T,
-    operator: Operator,
-    values: any | [any, any],
-  ): this {
-    const attrStr = String(attribute);
-    const nameKey = `#attr_${attrStr}`;
-    this.expressionAttributeNames[nameKey] = attrStr;
-
-    if (operator === "between") {
-      if (!Array.isArray(values) || values.length !== 2) {
-        throw new Error(
-          `For 'between' operator, values must be a tuple of two items`,
-        );
-      }
-      const valueKeyStart = `:val_start_${attrStr}`;
-      const valueKeyEnd = `:val_end_${attrStr}`;
-      this.expressionAttributeValues[valueKeyStart] = values[0];
-      this.expressionAttributeValues[valueKeyEnd] = values[1];
-      this.filters.push(
-        `${nameKey} BETWEEN ${valueKeyStart} AND ${valueKeyEnd}`,
-      );
-    } else if (operator === "begins_with" || operator === "contains") {
-      const valueKey = `:val_${attrStr}`;
-      this.expressionAttributeValues[valueKey] = values;
-      this.filters.push(`${operator}(${nameKey}, ${valueKey})`);
-    } else {
-      const valueKey = `:val_${attrStr}`;
-      this.expressionAttributeValues[valueKey] = values;
-      const condition = getOperatorExpression(operator, nameKey, valueKey);
-      this.filters.push(condition);
-    }
-    return this;
-  }
-
-  public limitResults(limit: number): this {
-    this.limit = limit;
-    return this;
-  }
-
-  public startFrom(lastKey: Record<string, any>): this {
-    this.lastKey = lastKey;
-    return this;
-  }
-
-  /**
-   * Executes the scan and returns a Promise that resolves with an array of items.
-   */
-  public async execute(): Promise<PaginatedResult<T>> {
-    const params: ScanCommandInput = {
-      TableName: this.parent.getTableName(),
-      ExpressionAttributeNames: this.expressionAttributeNames,
-      ExpressionAttributeValues: this.expressionAttributeValues,
-      Limit: this.limit,
-      ExclusiveStartKey: this.lastKey,
-    };
-
-    if (this.parent.getEntityType()) {
-      this.filters.push(`#entity = :entity_value`);
-      this.expressionAttributeNames["#entity"] = "entityType";
-      this.expressionAttributeValues[":entity_value"] =
-        this.parent.getEntityType();
-    }
-    params.FilterExpression = this.filters.join(" AND ");
-
-    const result = await this.parent.getClient().send(new ScanCommand(params));
-
-    return {
-      items: this.parent.getSchema().array().parse(result.Items) as T[],
-      lastKey: result.LastEvaluatedKey ?? undefined,
-    };
-  }
-}

package/src/builders/update-builder.ts

@@ -1,231 +0,0 @@
-import { TransactWriteCommand, UpdateCommand } from "@aws-sdk/lib-dynamodb";
-import { BetterDDB } from "../betterddb";
-import {
-  TransactWriteItem,
-  Update,
-  UpdateItemInput,
-} from "@aws-sdk/client-dynamodb";
-import { z } from "zod";
-interface UpdateActions<T> {
-  set?: Partial<T>;
-  remove?: (keyof T)[];
-  add?: Partial<Record<keyof T, number | Set<any>>>;
-  delete?: Partial<Record<keyof T, Set<any>>>;
-}
-
-export class UpdateBuilder<T> {
-  private actions: UpdateActions<T> = {};
-  private condition?: {
-    expression: string;
-    attributeValues: Record<string, any>;
-  };
-  // When using transaction mode, we store extra transaction items.
-  private extraTransactItems: TransactWriteItem[] = [];
-
-  // Reference to the parent BetterDDB instance and key.
-  constructor(
-    private parent: BetterDDB<T>,
-    private key: Partial<T>,
-  ) {}
-
-  // Chainable methods:
-  public set(attrs: Partial<T>): this {
-    const partialSchema = (
-      this.parent.getSchema() as unknown as z.ZodObject<any>
-    ).partial();
-    const validated = partialSchema.parse(attrs);
-    this.actions.set = { ...this.actions.set, ...validated };
-    return this;
-  }
-
-  public remove(attrs: (keyof T)[]): this {
-    this.actions.remove = [...(this.actions.remove || []), ...attrs];
-    return this;
-  }
-
-  public add(attrs: Partial<Record<keyof T, number | Set<any>>>): this {
-    const partialSchema = (
-      this.parent.getSchema() as unknown as z.ZodObject<any>
-    ).partial();
-    const validated = partialSchema.parse(attrs);
-    this.actions.add = { ...this.actions.add, ...validated };
-    return this;
-  }
-
-  public delete(attrs: Partial<Record<keyof T, Set<any>>>): this {
-    this.actions.delete = { ...this.actions.delete, ...attrs };
-    return this;
-  }
-
-  /**
-   * Adds a condition expression to the update.
-   */
-  public setCondition(
-    expression: string,
-    attributeValues: Record<string, any>,
-  ): this {
-    if (this.condition) {
-      // Merge conditions with AND.
-      this.condition.expression += ` AND ${expression}`;
-      Object.assign(this.condition.attributeValues, attributeValues);
-    } else {
-      this.condition = { expression, attributeValues };
-    }
-    return this;
-  }
-
-  /**
-   * Specifies additional transaction items to include when executing this update as a transaction.
-   */
-  public transactWrite(ops: TransactWriteItem[] | TransactWriteItem): this {
-    if (Array.isArray(ops)) {
-      this.extraTransactItems.push(...ops);
-    } else {
-      this.extraTransactItems.push(ops);
-    }
-    return this;
-  }
-
-  /**
-   * Builds the update expression and associated maps.
-   */
-  private buildExpression(): {
-    updateExpression: string;
-    attributeNames: Record<string, string>;
-    attributeValues: Record<string, any>;
-  } {
-    const ExpressionAttributeNames: Record<string, string> = {};
-    const ExpressionAttributeValues: Record<string, any> = {};
-    const clauses: string[] = [];
-
-    // Build SET clause.
-    if (this.actions.set) {
-      const setParts: string[] = [];
-      for (const [attr, value] of Object.entries(this.actions.set)) {
-        const nameKey = `#set_${attr}`;
-        const valueKey = `:set_${attr}`;
-        ExpressionAttributeNames[nameKey] = attr;
-        ExpressionAttributeValues[valueKey] = value;
-        setParts.push(`${nameKey} = ${valueKey}`);
-      }
-      if (setParts.length > 0) {
-        clauses.push(`SET ${setParts.join(", ")}`);
-      }
-    }
-
-    // Build REMOVE clause.
-    if (this.actions.remove && this.actions.remove.length > 0) {
-      const removeParts = this.actions.remove.map((attr) => {
-        const nameKey = `#remove_${String(attr)}`;
-        ExpressionAttributeNames[nameKey] = String(attr);
-        return nameKey;
-      });
-      clauses.push(`REMOVE ${removeParts.join(", ")}`);
-    }
-
-    // Build ADD clause.
-    if (this.actions.add) {
-      const addParts: string[] = [];
-      for (const [attr, value] of Object.entries(this.actions.add)) {
-        const nameKey = `#add_${attr}`;
-        const valueKey = `:add_${attr}`;
-        ExpressionAttributeNames[nameKey] = attr;
-        ExpressionAttributeValues[valueKey] = value;
-        addParts.push(`${nameKey} ${valueKey}`);
-      }
-      if (addParts.length > 0) {
-        clauses.push(`ADD ${addParts.join(", ")}`);
-      }
-    }
-
-    // Build DELETE clause.
-    if (this.actions.delete) {
-      const deleteParts: string[] = [];
-      for (const [attr, value] of Object.entries(this.actions.delete)) {
-        const nameKey = `#delete_${attr}`;
-        const valueKey = `:delete_${attr}`;
-        ExpressionAttributeNames[nameKey] = attr;
-        ExpressionAttributeValues[valueKey] = value;
-        deleteParts.push(`${nameKey} ${valueKey}`);
-      }
-      if (deleteParts.length > 0) {
-        clauses.push(`DELETE ${deleteParts.join(", ")}`);
-      }
-    }
-
-    // Merge any provided condition attribute values.
-    if (this.condition) {
-      Object.assign(ExpressionAttributeValues, this.condition.attributeValues);
-    }
-
-    return {
-      updateExpression: clauses.join(" "),
-      attributeNames: ExpressionAttributeNames,
-      attributeValues: ExpressionAttributeValues,
-    };
-  }
-
-  /**
-   * Returns a transaction update item that can be included in a transactWrite call.
-   */
-  public toTransactUpdate(): TransactWriteItem {
-    const { updateExpression, attributeNames, attributeValues } =
-      this.buildExpression();
-    const updateItem: Update = {
-      TableName: this.parent.getTableName(),
-      Key: this.parent.buildKey(this.key),
-      UpdateExpression: updateExpression,
-      ExpressionAttributeNames: attributeNames,
-      ExpressionAttributeValues: attributeValues,
-    };
-    if (this.condition && this.condition.expression) {
-      updateItem.ConditionExpression = this.condition.expression;
-    }
-    return { Update: updateItem };
-  }
-
-  /**
-   * Commits the update immediately by calling the parent's update method.
-   */
-  public async execute(): Promise<T> {
-    if (this.extraTransactItems.length > 0) {
-      // Build our update transaction item.
-      const myTransactItem = this.toTransactUpdate();
-      // Combine with extra transaction items.
-      const allItems = [...this.extraTransactItems, myTransactItem];
-      await this.parent.getClient().send(
-        new TransactWriteCommand({
-          TransactItems: allItems,
-        }),
-      );
-      // After transaction, retrieve the updated item.
-      const result = await this.parent.get(this.key).execute();
-      if (result === null) {
-        throw new Error("Item not found after transaction update");
-      }
-      return result;
-    } else {
-      // Normal update flow.
-      const { updateExpression, attributeNames, attributeValues } =
-        this.buildExpression();
-      const params: UpdateItemInput = {
-        TableName: this.parent.getTableName(),
-        Key: this.parent.buildKey(this.key),
-        UpdateExpression: updateExpression,
-        ExpressionAttributeNames: attributeNames,
-        ExpressionAttributeValues: attributeValues,
-        ReturnValues: "ALL_NEW",
-      };
-      if (this.condition && this.condition.expression) {
-        params.ConditionExpression = this.condition.expression;
-      }
-      const result = await this.parent
-        .getClient()
-        .send(new UpdateCommand(params));
-      if (!result.Attributes) {
-        throw new Error("No attributes returned after update");
-      }
-      return this.parent.getSchema().parse(result.Attributes) as T;
-    }
-  }
-}

package/src/index.ts

@@ -1 +0,0 @@
-export * from "./betterddb";

package/src/operator.ts

@@ -1,43 +0,0 @@
-export type Operator =
-  | "=="
-  | "!="
-  | "<"
-  | "<="
-  | ">"
-  | ">="
-  | "begins_with"
-  | "between"
-  | "contains";
-
-export function getOperatorExpression(
-  operator: Operator,
-  nameKey: string,
-  valueKey: string,
-  secondValueKey?: string,
-): string {
-  switch (operator) {
-    case "==":
-      return `${nameKey} = ${valueKey}`;
-    case "!=":
-      return `${nameKey} <> ${valueKey}`;
-    case "<":
-      return `${nameKey} < ${valueKey}`;
-    case "<=":
-      return `${nameKey} <= ${valueKey}`;
-    case ">":
-      return `${nameKey} > ${valueKey}`;
-    case ">=":
-      return `${nameKey} >= ${valueKey}`;
-    case "begins_with":
-      return `begins_with(${nameKey}, ${valueKey})`;
-    case "between":
-      if (!secondValueKey) {
-        throw new Error("The 'between' operator requires two value keys");
-      }
-      return `${nameKey} BETWEEN ${valueKey} AND ${secondValueKey}`;
-    case "contains":
-      return `contains(${nameKey}, ${valueKey})`;
-    default:
-      throw new Error("Unsupported operator");
-  }
-}

package/src/types/paginated-result.ts

@@ -1,4 +0,0 @@
-export type PaginatedResult<T> = {
-  items: T[];
-  lastKey: Record<string, any> | undefined;
-};

package/test/batch-get.test.ts

@@ -1,97 +0,0 @@
-import { z } from 'zod';
-import { BetterDDB } from '../src/betterddb';
-import { createTestTable, deleteTestTable } from './utils/table-setup';
-import { DynamoDBDocumentClient } from '@aws-sdk/lib-dynamodb';
-import { DynamoDB, GlobalSecondaryIndex } from '@aws-sdk/client-dynamodb';
-import { KeySchemaElement, AttributeDefinition } from '@aws-sdk/client-dynamodb';
-const TEST_TABLE = "batch-get-test-table";
-const ENDPOINT = 'http://localhost:4566';
-const REGION = 'us-east-1';
-const ENTITY_TYPE = 'USER';
-const PRIMARY_KEY = 'pk';
-const PRIMARY_KEY_TYPE = 'S';
-const SORT_KEY = 'sk';
-const SORT_KEY_TYPE = 'S';
-const GSI_NAME = 'EmailIndex';
-const GSI_PRIMARY_KEY = 'gsi1pk';
-const GSI_SORT_KEY = 'gsi1sk';
-const KEY_SCHEMA = [
-  { AttributeName: PRIMARY_KEY, KeyType: 'HASH' },
-  { AttributeName: SORT_KEY, KeyType: 'RANGE' }
-] as KeySchemaElement[];
-const ATTRIBUTE_DEFINITIONS = [
-  { AttributeName: PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE },
-  { AttributeName: SORT_KEY, AttributeType: SORT_KEY_TYPE },
-  { AttributeName: GSI_PRIMARY_KEY, AttributeType: PRIMARY_KEY_TYPE },
-  { AttributeName: GSI_SORT_KEY, AttributeType: SORT_KEY_TYPE },
-] as AttributeDefinition[];
-const GSIS = [
-  {
-    IndexName: GSI_NAME,
-    KeySchema: [{ AttributeName: GSI_PRIMARY_KEY, KeyType: 'HASH' }, { AttributeName: GSI_SORT_KEY, KeyType: 'RANGE' }],
-    Projection: {
-      ProjectionType: 'ALL',
-    },
-  },
-] as GlobalSecondaryIndex[];
-const client = DynamoDBDocumentClient.from(new DynamoDB({
-  region: REGION,
-  endpoint: ENDPOINT,
-}));
-
-
-const UserSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  email: z.string().email(),
-});
-
-type User = z.infer<typeof UserSchema>;
-
-const userDdb = new BetterDDB({
-  schema: UserSchema,
-  tableName: TEST_TABLE,
-  entityType: ENTITY_TYPE,
-  keys: {
-    primary: { name: PRIMARY_KEY, definition: { build: (raw) => raw.id! } },
-    sort: { name: SORT_KEY, definition: { build: (raw) => raw.email! } },
-  },
-  client,
-  timestamps: true,
-});
-
-beforeAll(async () => {
-  await createTestTable(TEST_TABLE, KEY_SCHEMA, ATTRIBUTE_DEFINITIONS, GSIS);
-  await userDdb.create({ id: 'user-123', name: 'John Doe', email: 'john@example.com' } as any).execute();
-  await userDdb.create({ id: 'user-124', name: 'John Doe', email: 'john@example.com' } as any).execute();
-  await userDdb.create({ id: 'user-125', name: 'Bob Doe', email: 'bob@example.com' } as any).execute();
-});
-
-afterAll(async () => {
-  await deleteTestTable(TEST_TABLE);
-});
-
-describe('BetterDDB - Get Operation', () => {
-  it('should retrieve an item using GetBuilder', async () => {
-    const users = await userDdb.batchGet([{ id: 'user-123', email: 'john@example.com' }, { id: 'user-124', email: 'john@example.com' }]).execute();
-    expect(users.length).toEqual(2);
-    expect(users.some(user => user.id === 'user-123')).toBe(true);
-    expect(users.some(user => user.id === 'user-124')).toBe(true);
-  });
-
-  it('should retrieve an item using GetBuilder that does not exist', async () => {
-    const users = await userDdb.batchGet([{ id: 'user-123', email: 'jane@example.com' }]).execute();
-    expect(users.length).toEqual(0);
-  });
-
-  it('should return an empty array if no keys are provided', async () => {
-    const users = await userDdb.batchGet([]).execute();
-    expect(users.length).toEqual(0);
-  });
-
-  it('should deduplicate keys', async () => {
-    const users = await userDdb.batchGet([{ id: 'user-123', email: 'john@example.com' }, { id: 'user-123', email: 'john@example.com' }]).execute();
-    expect(users.length).toEqual(1);
-    expect(users[0].id).toEqual('user-123');
-  });
-});