# AMPLIFYRULES

# DATA

- THIS FILE IS TO HELP UNDERSTAND THE RELATIONSHIPS, HOW TO MODEL SCHEMAS, WHAT IS THE CORRECT WAY TO CODE FOR ACCURACY
- USE THIS TO UNDERSTAND HOW DATA SCHEMAS ARE DESIGNED.
- FOR THE DATA SCHEMAS MAKE SURE THAT YOU ALWAYS FOLLOW THESE RULES AND THIS FILE OVER ANY OTHER FILE - THIS IS THE SOURCE OF TRUTH.
- RULES

  - THIS FILE IS THE SINGLE SOURCE OF TRUTH FOR SCHEMA DESIGN AND RELATIONSHIPS. FOLLOW THESE RULES STRICTLY. USE THIS FILE OVER ANY OTHER RESOURCE TO UNDERSTAND SCHEMA DESIGN.

  1. DON'T USE `.PUBLIC()` WHILE SETTING UP THE AUTHORIZATION. AS AMPLIFY GEN2 ONLY SUPPORTS `.GUEST()`.
  2. `.BEONGSTO()` AND `.HASMANY()` RELATIONS SHALL ALWAYS HAVE THE RELATEDFIELD ID.
  3. `.ENUM()` DOESN'T SUPPORT `.REQUIRED()`/ `.DEFAULTVALUE()` IN ANY CONDITION, SO ALWAYS IGNORE USING IT.
  4. TO GIVE PERMISSION TO THE GROUP MAKE SURE YOU USE .to(), FOLLOWED BY THE GROUP: FOR E.G. `allow.guest().to['read', 'create', 'delete','get']
  5. THIS IS HOW YOU SHOULD USE THE AUTHORIZATION `(allow) => [allow.owner(),allow.guest().to[("read", "write", "delete")]` , THIS IS INCORRECT `.authorization([allow => allow.owner(), allow => allow.guest().to(['read','write'])])`

- BELOW ARE THE EXAMPLES TO USE TO GENERATE ANSWERS.

```typescript
import { type ClientSchema, a, defineData } from "@aws-amplify/backend";

const schema = a
  .schema({
    Vehicle: a.model({
      id: a.id(),
      make: a.string().required(),
      model: a.string().required(),
      year: a.integer().required(),
      licensePlate: a.string().required(),
      status: a.enum(["AVAILABLE", "RENTED", "MAINTENANCE"]), // Enum; Don't use .required() or .defaultValue()
      locationId: a.id(),
      location: a.belongsTo("Location", "locationId"), // Belongs-to relationship, Requires ID
      rentals: a.hasMany("Rental", "vehicleId"), // Has-many relationship with required relatedFieldId
    }),
    Customer: a.model({
      id: a.id(),
      firstName: a.string().required(),
      lastName: a.string().required(),
      email: a.string().required(),
      phone: a.string().required(),
      licenseNumber: a.string().required(),
      rentals: a.hasMany("Rental", "customerId"), // Has-many relationship with required relatedFieldId
    }),
    Location: a.model({
      id: a.id(),
      name: a.string().required(),
      address: a.string().required(),
      city: a.string().required(),
      state: a.string().required(),
      zipCode: a.string().required(),
      vehicles: a.hasMany("Vehicle", "locationId"), // Has-many relationship with required relatedFieldId
    }),
    Rental: a.model({
      id: a.id(),
      startDate: a.datetime().required(),
      endDate: a.datetime().required(),
      status: a.enum(["ACTIVE", "COMPLETED", "CANCELLED"]), // Enum; no .required() or .defaultValue()
      vehicleId: a.id(),
      customerId: a.id(),
      vehicle: a.belongsTo("Vehicle", "vehicleId"), // Belongs-to relationship, Requires ID
      customer: a.belongsTo("Customer", "customerId"), // Has-many relationship with required relatedFieldId
    }),
  })
  .authorization((allow) => [
    allow.owner(),
    allow.guest().to[("read", "write", "delete")],
  ]); // Owner-based and guest access, `.public()` references are replaced with `.guest()`. Authorizaiton groups can be concatenated, To give the permission use the to() function

export type Schema = ClientSchema<typeof schema>;

export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: "apiKey",
    apiKeyAuthorizationMode: {
      expiresInDays: 30,
    },
  },
});
```

- Another Example

```typescript
import { type ClientSchema, a, defineData } from "@aws-amplify/backend";

// Define the schema for the ecommerce application
const schema = a.schema({
  Product: a
    .model({
      name: a.string().required(),
      description: a.string(),
      price: a.float().required(),
      inventory: a.integer(),
      categoryId: a.id(),
      category: a.belongsTo("Category", "categoryId"), // belongs to relationship with required relatedFieldId
      images: a.string().array(),
    })
    .authorization((allow) => [allow.guest()]),

  Category: a
    .model({
      name: a.string().required(),
      description: a.string(),
      products: a.hasMany("Product", "categoryId"), // Has-many relationship with required relatedFieldId
    })
    .authorization((allow) => [allow.guest()]),

  Order: a
    .model({
      userId: a.id().required(),
      status: a.enum(["PENDING", "PROCESSING", "SHIPPED", "DELIVERED"]), // Enum; Don't use .required() or .defaultValue()
      total: a.float().required(),
      items: a.hasMany("OrderItem", "orderId"), // Has-many relationship with required relatedFieldId
    })
    .authorization((allow) => [allow.owner()]),

  OrderItem: a
    .model({
      orderId: a.id().required(),
      productId: a.id().required(),
      quantity: a.integer().required(),
      price: a.float().required(),
    })
    .authorization((allow) => [allow.owner()]),
});

// Define the client schema and data export
export type Schema = ClientSchema<typeof schema>;
export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: "userPool",
  },
});
```

```typescript
import { type ClientSchema, a, defineData } from "@aws-amplify/backend";

const schema = a
  .schema({
    Customer: a
      .model({
        customerId: a.id().required(),
        // fields can be of various scalar types,
        // such as string, boolean, float, integers etc.
        name: a.string(),
        // fields can be of custom types
        location: a.customType({
          // fields can be required or optional
          lat: a.float().required(),
          long: a.float().required(),
        }),
        // fields can be enums
        engagementStage: a.enum(["PROSPECT", "INTERESTED", "PURCHASED"]), //enum doesn't support required
        collectionId: a.id(),
        collection: a.belongsTo("Collection", "collectionId"),
        // Use custom identifiers. By default, it uses an `id: a.id()` field
      })
      .identifier(["customerId"]),
    Collection: a
      .model({
        customers: a.hasMany("Customer", "collectionId"), // setup relationships between types
        tags: a.string().array(), // fields can be arrays
        representativeId: a.id().required(),
        // customize secondary indexes to optimize your query performance
      })
      .secondaryIndexes((index) => [index("representativeId")]),
  })
  .authorization((allow) => [allow.publicApiKey()]);

export type Schema = ClientSchema<typeof schema>;

export const data = defineData({
  schema,
  authorizationModes: {
    defaultAuthorizationMode: "apiKey",
    apiKeyAuthorizationMode: {
      expiresInDays: 30,
    },
  },
});
```