find() has no _type condition when using gsi

[TTMoon]

ISSUES will not receive priority that do not follow this template or cannot be easily reproduced or diagnosed

Describe the bug
find() has no _type condition when using gsi

To Reproduce

Table Schema

{
  "TableName": "example-local",
  "AttributeDefinitions": [
    { "AttributeName": "pk", "AttributeType": "S" },
    { "AttributeName": "sk", "AttributeType": "S" },
    { "AttributeName": "gsi1pk", "AttributeType": "S" },
    { "AttributeName": "gsi1sk", "AttributeType": "S" },
    { "AttributeName": "gsi2pk", "AttributeType": "S" },
    { "AttributeName": "gsi2sk", "AttributeType": "S" }
  ],
  "KeySchema": [
    { "AttributeName": "pk", "KeyType": "HASH" },
    { "AttributeName": "sk", "KeyType": "RANGE" }
  ],
  "GlobalSecondaryIndexes": [
    {
      "IndexName": "gsi1",
      "KeySchema": [
        { "AttributeName": "gsi1pk", "KeyType": "HASH" },
        { "AttributeName": "gsi1sk", "KeyType": "RANGE" }
      ],
      "Projection": {
        "ProjectionType": "ALL"
      }
    },
    {
      "IndexName": "gsi2",
      "KeySchema": [
        { "AttributeName": "gsi2pk", "KeyType": "HASH" },
        { "AttributeName": "gsi2sk", "KeyType": "RANGE" }
      ],
      "Projection": {
        "ProjectionType": "ALL"
      }
    }
  ],
  "BillingMode": "PAY_PER_REQUEST"
}

Model

{
  pk: { type: String, value: 'example#${id}' },
  sk: { type: String, value: 'example#' },

  id: { type: String, uuid: 'ulid' },
  name: { type: String },
  
  gsi1pk: { type: String, value: 'example#${id}' },
  gsi1sk: { type: String, value: 'example#' },

  gsi2pk: { type: String, value: 'example#' },
  gsi2sk: { type: String, value: '${name}' },
};

Code

const table = new Table({
  name: process.env.TABLE_NAME,
  client,
  schema,
  logger: true,
});

const exampleClient = table.getModel<Example>('Example');

const result = await exampleClient.find({}, {
      limit: 25,
      next,
      index: 'gsi2',
      log: true,
      follow: false,
    });

Log

info OneTable result for "find" "Example" {
    "cmd": {
        "ExpressionAttributeNames": {
            "#_0": "gsi2pk"
        },
        "ExpressionAttributeValues": {
            ":_0": "example#"
        },
        "KeyConditionExpression": "#_0 = :_0",
        "TableName": "example",
        "ConsistentRead": false,
        "IndexName": "gsi2",
        "Limit": 21,
        "ScanIndexForward": true
    },
    "items": [],
    "op": "find",
    "properties": {
        "gsi2pk": "example#"
    },
    "params": {
        "parse": true,
        "high": true,
        "limit": 25,
        "index": "gsi2",
        "log": true,
        "follow": false,
        "checked": true
    }
}

Expected behavior

"cmd": {
        "ExpressionAttributeNames": {
            "#_0": "_type",
            "#_1": "gsi2pk"
        },
        "ExpressionAttributeValues": {
            ":_0": "Example",
            ":_1": "example#"
        },
        "FilterExpression": "#_0 = :_0",
        "KeyConditionExpression": "#_1 = :_1",
        "TableName": "example",
        "ConsistentRead": false,
        "IndexName": "gsi2",
        "Limit": 19,
        "ScanIndexForward": true
    }

Environment (please complete the following information):

• OS : Mac OSX
• Node Version : 16.4.2
• OneTable Version : 2.1.0

[mobsense]

Were you expecting a filter expression to test _type == 'Example'?

But that not necessary. If the GSI2PK == 'example#' then that will only match example types. A filter expression on _type is not required and not used.

Even if finding with the primary index, a filter expression on _type is not required.

[TTMoon]

AWS Example
refer to this example

HR-Employee - PK: EmployeeID, SK: Employee Name
OE-Order - PK OrderID, SK: CustomerID

Both have the same gsi1pk EMPYLOYEE1

If there is no _type expression, EmployeeClient returns Employee and Order both when using gsi1

"ExpressionAttributeNames": {
            "#_0": "gsi1pk"
        },
        "ExpressionAttributeValues": {
            ":_0": "EMPLOYEE1"
        },
        "KeyConditionExpression": "#_0 = :_0",
        "TableName": "example",
        "ConsistentRead": false,
        "IndexName": "gsi1",
        "Limit": 21,
        "ScanIndexForward": true

There is no filter in this expression that filter Employee and Order

[mobsense]

I don't see any 'type' attribute in that table at all. Am I missing something?

Some early AWS examples were before thinking evolved on how to do single-table patterns and before the use of a 'type' attribute was seen as best practice.

OneTable expects and requires a 'type' attribute. It automatically defines this in the schema behind the scenes so all items have a type. Newer AWS examples by Rick H et al, have a type attribute for items.

Now if you are using an existing model, you need to first ensure it has a type attribute and it is set to the name of each model.

[TTMoon]

I attached it only to show gsi1pk is the same model.

To explain in more detail,
Assuming that there are 1 Employees and 10 orders that have a same gsi1pk 'EMPLOYEE1'
When this code was executed,

const employeeClient = table.getModel<Employee>('Employee');

const result = await employeeClient.find({
    gsi1pk: 'EMPLOYEE1',
}, {
      limit: 25,
      next,
      index: 'gsi1',
      log: true,
      follow: false,
    });

I expected that employclient returns only 1 data that _type is Employee.
But this code returned 11 data including Orders.

[mobsense]

That query will return any items that use that GSI PK which is 'EMPLOYEE1'. So you will get multiple items. Your GSI SK does not discriminate based on type. You use:

  gsi1sk: { type: String, value: 'example#' },

Whereas if you used:

gsi1sk: {type: String, value: 'example#${_type}'}

that would then return only the employee (provided your data has a _type attribute).

Also, typically you should not be providing the GSI PK, but rather be providing the ID and let OneTable calculate the PK value from the value template.

[mobsense]

I'm going to move this to discussions as this is a useful stream for others.