storepb

type BaseEntity struct {
	Id         *EntityID   `protobuf:"bytes,1,opt,name=id,proto3" json:"id,omitempty"`
	Timestamps *Timestamps `protobuf:"bytes,2,opt,name=timestamps,proto3" json:"timestamps,omitempty"`
	// contains filtered or unexported fields
}

type BaseEntityScanner struct {
	Id        int64     `json:"id"` // origin: type_alias, empath: id
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

type Category struct {

	// Embedded BaseEntity (id + timestamps)
	Base     *BaseEntity            `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Name     string                 `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Slug     string                 `protobuf:"bytes,3,opt,name=slug,proto3" json:"slug,omitempty"`
	ParentId *wrapperspb.Int64Value `protobuf:"bytes,4,opt,name=parent_id,json=parentId,proto3" json:"parent_id,omitempty"`
	// contains filtered or unexported fields
}

type CategoryAlias string

type CategoryColumnAlias string

type CategoryScanner struct {
	Id        int64     `json:"id"` // origin: embed, empath: id
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
	Name      string    `json:"name"`
	Slug      string    `json:"slug"`
	ParentId  int64     `json:"parentId"`
}

type CategorysTable struct {
	*schema.Table[CategoryAlias, CategoryColumnAlias, *CategoryScanner]
	Id        schema.BigSerialColumnI[CategoryColumnAlias]
	CreatedAt schema.TimestamptzColumnI[CategoryColumnAlias]
	UpdatedAt schema.TimestamptzColumnI[CategoryColumnAlias]
	Name      schema.TextColumnI[CategoryColumnAlias]
	Slug      schema.TextColumnI[CategoryColumnAlias]
	ParentId  schema.NullBigIntColumnI[CategoryColumnAlias]
}

type Currency struct {
	Code string `protobuf:"bytes,1,opt,name=code,proto3" json:"code,omitempty"`
	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	// contains filtered or unexported fields
}

type CurrencyAlias string

type CurrencyColumnAlias string

type CurrencyScanner struct {
	Code string `json:"code"`
	Name string `json:"name"`
}

type CurrencysTable struct {
	*schema.Table[CurrencyAlias, CurrencyColumnAlias, *CurrencyScanner]
	Code schema.TextColumnI[CurrencyColumnAlias]
	Name schema.TextColumnI[CurrencyColumnAlias]
}

type EntityID struct {
	Value int64 `protobuf:"varint,1,opt,name=value,proto3" json:"value,omitempty"`
	// contains filtered or unexported fields
}

type Order struct {

	// Embedded BaseEntity (id + timestamps)
	Base     *BaseEntity `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	UserId   *EntityID   `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` // FK to users.id
	Status   string      `protobuf:"bytes,3,opt,name=status,proto3" json:"status,omitempty"`
	Currency string      `protobuf:"bytes,4,opt,name=currency,proto3" json:"currency,omitempty"` // FK to currency.code
	// OneToMany: Order has many OrderItems
	Items []*OrderItem `protobuf:"bytes,10,rep,name=items,proto3" json:"items,omitempty"`
	// BelongsTo: Order belongs to User
	User *User `protobuf:"bytes,11,opt,name=user,proto3" json:"user,omitempty"`
	// BelongsTo: Order belongs to Currency
	Money *Currency `protobuf:"bytes,12,opt,name=money,proto3" json:"money,omitempty"`
	// contains filtered or unexported fields
}

type OrderAlias string

type OrderColumnAlias string

type OrderItem struct {
	OrderId   *EntityID `protobuf:"bytes,1,opt,name=order_id,json=orderId,proto3" json:"order_id,omitempty"` // FK to orders.id
	LineNo    int32     `protobuf:"varint,2,opt,name=line_no,json=lineNo,proto3" json:"line_no,omitempty"`
	ProductId *EntityID `protobuf:"bytes,3,opt,name=product_id,json=productId,proto3" json:"product_id,omitempty"` // FK to products.id
	Qty       int32     `protobuf:"varint,4,opt,name=qty,proto3" json:"qty,omitempty"`
	UnitPrice float64   `protobuf:"fixed64,5,opt,name=unit_price,json=unitPrice,proto3" json:"unit_price,omitempty"`
	// BelongsTo: OrderItem belongs to Order
	Order *Order `protobuf:"bytes,10,opt,name=order,proto3" json:"order,omitempty"`
	// BelongsTo: OrderItem belongs to Product
	Product *Product `protobuf:"bytes,11,opt,name=product,proto3" json:"product,omitempty"`
	// contains filtered or unexported fields
}

type OrderItemAlias string

type OrderItemColumnAlias string

type OrderItemScanner struct {
	OrderId   int64           `json:"orderId"` // origin: type_alias, empath: order_id
	LineNo    int32           `json:"lineNo"`
	ProductId int64           `json:"productId"` // origin: type_alias, empath: product_id
	Qty       int32           `json:"qty"`
	UnitPrice float64         `json:"unitPrice"`
	Order     *OrderScanner   `json:"order"`
	Product   *ProductScanner `json:"product"`
}

type OrderItemsTable struct {
	*schema.Table[OrderItemAlias, OrderItemColumnAlias, *OrderItemScanner]
	OrderId   schema.BigIntColumnI[OrderItemColumnAlias]
	LineNo    schema.IntegerColumnI[OrderItemColumnAlias]
	ProductId schema.BigIntColumnI[OrderItemColumnAlias]
	Qty       schema.IntegerColumnI[OrderItemColumnAlias]
	UnitPrice schema.DoublePrecisionColumnI[OrderItemColumnAlias]
}

type OrderScanner struct {
	Id        int64              `json:"id"` // origin: embed, empath: id
	CreatedAt time.Time          `json:"createdAt"`
	UpdatedAt time.Time          `json:"updatedAt"`
	UserId    int64              `json:"userId"` // origin: type_alias, empath: user_id
	Status    string             `json:"status"`
	Currency  string             `json:"currency"`
	Items     []OrderItemScanner `json:"items"`
	User      *UserScanner       `json:"user"`
	Money     *CurrencyScanner   `json:"money"`
}

type OrdersTable struct {
	*schema.Table[OrderAlias, OrderColumnAlias, *OrderScanner]
	Id        schema.BigSerialColumnI[OrderColumnAlias]
	CreatedAt schema.TimestamptzColumnI[OrderColumnAlias]
	UpdatedAt schema.TimestamptzColumnI[OrderColumnAlias]
	UserId    schema.BigIntColumnI[OrderColumnAlias]
	Status    schema.TextColumnI[OrderColumnAlias]
	Currency  schema.TextColumnI[OrderColumnAlias]
}

type Product struct {

	// Embedded BaseEntity (id + timestamps)
	Base      *BaseEntity `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Sku       string      `protobuf:"bytes,2,opt,name=sku,proto3" json:"sku,omitempty"`
	Name      string      `protobuf:"bytes,3,opt,name=name,proto3" json:"name,omitempty"`
	Price     float64     `protobuf:"fixed64,4,opt,name=price,proto3" json:"price,omitempty"`
	Currency  string      `protobuf:"bytes,5,opt,name=currency,proto3" json:"currency,omitempty"` // FK to currency.code
	StockQty  int32       `protobuf:"varint,6,opt,name=stock_qty,json=stockQty,proto3" json:"stock_qty,omitempty"`
	IsDeleted bool        `protobuf:"varint,7,opt,name=is_deleted,json=isDeleted,proto3" json:"is_deleted,omitempty"`
	// ManyToMany: Product has many Categories
	Categories []*Category `protobuf:"bytes,10,rep,name=categories,proto3" json:"categories,omitempty"`
	// ManyToMany: Product has many Tags
	Tags []*Tag `protobuf:"bytes,11,rep,name=tags,proto3" json:"tags,omitempty"`
	// contains filtered or unexported fields
}

type ProductAlias string

type ProductColumnAlias string

type ProductScanner struct {
	Id         int64             `json:"id"` // origin: embed, empath: id
	CreatedAt  time.Time         `json:"createdAt"`
	UpdatedAt  time.Time         `json:"updatedAt"`
	Sku        string            `json:"sku"`
	Name       string            `json:"name"`
	Price      float64           `json:"price"`
	Currency   string            `json:"currency"`
	StockQty   int32             `json:"stockQty"`
	IsDeleted  bool              `json:"isDeleted"`
	Categories []CategoryScanner `json:"categories"`
	Tags       []TagScanner      `json:"tags"`
}

type ProductsTable struct {
	*schema.Table[ProductAlias, ProductColumnAlias, *ProductScanner]
	Id        schema.BigSerialColumnI[ProductColumnAlias]
	CreatedAt schema.TimestamptzColumnI[ProductColumnAlias]
	UpdatedAt schema.TimestamptzColumnI[ProductColumnAlias]
	Sku       schema.TextColumnI[ProductColumnAlias]
	Name      schema.TextColumnI[ProductColumnAlias]
	Price     schema.DoublePrecisionColumnI[ProductColumnAlias]
	Currency  schema.TextColumnI[ProductColumnAlias]
	StockQty  schema.IntegerColumnI[ProductColumnAlias]
	IsDeleted schema.BooleanColumnI[ProductColumnAlias]
}

type Profile struct {

	// Embedded BaseEntity (id + timestamps)
	Base      *BaseEntity `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	UserId    *EntityID   `protobuf:"bytes,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"` // FK to users.id (unique - one profile per user)
	Bio       string      `protobuf:"bytes,3,opt,name=bio,proto3" json:"bio,omitempty"`
	AvatarUrl string      `protobuf:"bytes,4,opt,name=avatar_url,json=avatarUrl,proto3" json:"avatar_url,omitempty"`
	// BelongsTo: Profile belongs to User
	User *User `protobuf:"bytes,10,opt,name=user,proto3" json:"user,omitempty"`
	// contains filtered or unexported fields
}

type ProfileAlias string

type ProfileColumnAlias string

type ProfileScanner struct {
	Id        int64        `json:"id"` // origin: embed, empath: id
	CreatedAt time.Time    `json:"createdAt"`
	UpdatedAt time.Time    `json:"updatedAt"`
	UserId    int64        `json:"userId"` // origin: type_alias, empath: user_id
	Bio       string       `json:"bio"`
	AvatarUrl string       `json:"avatarUrl"`
	User      *UserScanner `json:"user"`
}

type ProfilesTable struct {
	*schema.Table[ProfileAlias, ProfileColumnAlias, *ProfileScanner]
	Id        schema.BigSerialColumnI[ProfileColumnAlias]
	CreatedAt schema.TimestamptzColumnI[ProfileColumnAlias]
	UpdatedAt schema.TimestamptzColumnI[ProfileColumnAlias]
	UserId    schema.BigIntColumnI[ProfileColumnAlias]
	Bio       schema.TextColumnI[ProfileColumnAlias]
	AvatarUrl schema.TextColumnI[ProfileColumnAlias]
}

type Tag struct {

	// Embedded BaseEntity (id + timestamps)
	Base *BaseEntity `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Name string      `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
	Slug string      `protobuf:"bytes,3,opt,name=slug,proto3" json:"slug,omitempty"`
	// contains filtered or unexported fields
}

type TagAlias string

type TagColumnAlias string

type TagScanner struct {
	Id        int64     `json:"id"` // origin: embed, empath: id
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
	Name      string    `json:"name"`
	Slug      string    `json:"slug"`
}

type TagsTable struct {
	*schema.Table[TagAlias, TagColumnAlias, *TagScanner]
	Id        schema.BigSerialColumnI[TagColumnAlias]
	CreatedAt schema.TimestamptzColumnI[TagColumnAlias]
	UpdatedAt schema.TimestamptzColumnI[TagColumnAlias]
	Name      schema.TextColumnI[TagColumnAlias]
	Slug      schema.TextColumnI[TagColumnAlias]
}

type Timestamps struct {
	CreatedAt *timestamppb.Timestamp `protobuf:"bytes,1,opt,name=created_at,json=createdAt,proto3" json:"created_at,omitempty"`
	UpdatedAt *timestamppb.Timestamp `protobuf:"bytes,2,opt,name=updated_at,json=updatedAt,proto3" json:"updated_at,omitempty"`
	// contains filtered or unexported fields
}

type TimestampsScanner struct {
	CreatedAt time.Time `json:"createdAt"`
	UpdatedAt time.Time `json:"updatedAt"`
}

type User struct {

	// Embedded BaseEntity (id + timestamps)
	Base     *BaseEntity `protobuf:"bytes,1,opt,name=base,proto3" json:"base,omitempty"`
	Email    string      `protobuf:"bytes,2,opt,name=email,proto3" json:"email,omitempty"`
	FullName string      `protobuf:"bytes,3,opt,name=full_name,json=fullName,proto3" json:"full_name,omitempty"`
	IsActive bool        `protobuf:"varint,4,opt,name=is_active,json=isActive,proto3" json:"is_active,omitempty"`
	// OneToMany: User has many Orders
	Orders []*Order `protobuf:"bytes,10,rep,name=orders,proto3" json:"orders,omitempty"`
	// HasOne: User has one Profile
	Profile *Profile `protobuf:"bytes,11,opt,name=profile,proto3" json:"profile,omitempty"`
	// contains filtered or unexported fields
}

type UserAlias string

type UserColumnAlias string

type UserScanner struct {
	Id        int64           `json:"id"` // origin: embed, empath: id
	CreatedAt time.Time       `json:"createdAt"`
	UpdatedAt time.Time       `json:"updatedAt"`
	Email     string          `json:"email"`
	FullName  string          `json:"fullName"`
	IsActive  bool            `json:"isActive"`
	Orders    []OrderScanner  `json:"orders"`
	Profile   *ProfileScanner `json:"profile"`
}

type UsersTable struct {
	*schema.Table[UserAlias, UserColumnAlias, *UserScanner]
	Id        schema.BigSerialColumnI[UserColumnAlias]
	CreatedAt schema.TimestamptzColumnI[UserColumnAlias]
	UpdatedAt schema.TimestamptzColumnI[UserColumnAlias]
	Email     schema.TextColumnI[UserColumnAlias]
	FullName  schema.TextColumnI[UserColumnAlias]
	IsActive  schema.BooleanColumnI[UserColumnAlias]
}