Schema

type Employee @model {
    # This corresponds to the primary key of the Employee table
    Id: ID

    FirstName: String
    LastName: String
}

type Employee
    @model(tableName: "employees")
    @autoTimestamp
    @crud(delete: false) {
    id: ID
    logins: Int @autoIncrement
    firstName: String @column(name: "FirstName")
}

type Post @model(tableName: 'Posts') @autoTimestamp {
    id: UUID @primaryKey
    permalink: URL! @column(name: "perma_link")
    authorId: Email
    origin: IPV4
    content: JSON
    birthday: Date
}

type Profile @model {
    id: ID @primaryKey

    # Validate post code
    postcode: String @validate_is(value: "[A-Z]{1,2}[0-9][0-9A-Z]?\s?[0-9][A-Z]{2}")

    # Title must be Mr|Mrs
    title: String @validate_contains(value: "Mr")

    #  Must be at least 18 years
    dob: String @validate_isAfter(value: "2004-01-01")

    # Address is of 20 characters long
    address: String @validate_len(value: 20)
}

erDiagram
    OrderDetail ||..|| Product: Product

    OrderDetail {
        int Id PK
        float Quantity
        string ProductId FK
    }

    Product {
        int Id PK
        float UnitPrice
    }

type Customer @model {
    Id: ID
    ContactName: String
    Orders: [Order] @hasMany(onDelete: "CASCADE")
}

type Order @model {
    Id: Int @primaryKey @autoIncrement
    OrderDate: Date
    Freight: Float
    CustomerId: String
    Customer: Customer
        @belongsTo(foreignKey: "CustomerId", onDelete: "SET NULL")
}

{
    find_orderdetails(limit: 1) {
        orderdetails {
            Product {
                ProductName
            }
        }
    }
}

type Customer @model {
    ID: String
    ContactName: String

    Orders: [Order] @hasMany(foreignKey: 'CustomerId')
}

type Order @model {
    Id: ID
    ShipCountry: String
    CustomerId: String
}

{
    find_customers(limit: 2) {
        customers {
            Orders(limit: 5) {
                ShippedDate
            }
        }
    }
}

erDiagram
Order ||--o{ OrderDetail: has
Product ||--o{ OrderDetail: belongs

Order {
    string Id PK
    date   OrderDate
    string ShipName
    string ShipAddress
}

OrderDetail {
    int Id PK
    string CustomerId FK
    string ProductId FK
}

Product {
    int Id PK
    string ProductName
    float UnitPrice
    int ReorderLevel
}

type Order @model {
    Id: ID
    OrderDate: Date

    Products: [Product] @belongsToMany(through: "OrderDetail")
}

type OrderDetail @model {
    Id: ID
    Quantity: Float

    # The many-to-many relationship expects these Ids to exist on this table in this exact format. i.e ModelId
    # If this not the case, the column name can be mapped instead.
    OrderId: String
    # This is an example of how to keep the schema rules mapped to the underlying database
    ProductId: String @column(name: "ProductId")

    Order: Product @belongsTo(sourceKey: "OrderId")
    Product: Product @belongsTo(sourceKey: "ProductId")
}

type Product @model {
    Id: ID
    ProductName: String
    UnitPrice: Float
}

# Find the products attached to an order with price greater than 20
{
    find_orders(limit: 1) {
        orders {
            Products(where: { UnitPrice: { gt: 20 } }) {
                UnitPrice
                ProductName
            }
        }
    }
}

type Employee @model {
    Id: Int @primaryKey
    FirstName: String
    ReportsTo: Int

    Manager: Employee @belongsTo(foreignKey: "ReportsTo")
    Manages: [Employee] @hasMany(foreignKey: "ReportsTo")
}

{
    find_employee_by_pk(id: 5) {
        FirstName
        Manager {
            FirstName
        }
        Manages {
            FirstName
        }
        Manages_aggregate {
            count
        }
    }
}