models

var Categories = func() CategoriesTable {
	categoryIDCol := schema.BigSerialColumn(CategoriesColumnCategoryID, ddl.WithPrimaryKey[CategoriesColumnAlias]())
	nameCol := schema.TextColumn(CategoriesColumnName, ddl.WithNotNull[CategoriesColumnAlias]())
	slugCol := schema.TextColumn(
		CategoriesColumnSlug,
		ddl.WithNotNull[CategoriesColumnAlias](),
		ddl.WithUnique[CategoriesColumnAlias](),
	)
	parentIDCol := schema.BigIntColumn(
		CategoriesColumnParentID,
		ddl.WithReferences[CategoriesColumnAlias]("categories", "category_id"),
	)

	return CategoriesTable{
		Table: schema.NewTable[CategoriesAlias, CategoriesColumnAlias, *CategoriesScanner](
			CategoriesAliasName,
			func() *CategoriesScanner { return &CategoriesScanner{} },
			[]*ddl.ColumnDDL[CategoriesColumnAlias]{
				categoryIDCol.DDL(),
				nameCol.DDL(),
				slugCol.DDL(),
				parentIDCol.DDL(),
			},
		),
		CategoryID: categoryIDCol,
		Name:       nameCol,
		Slug:       slugCol,
		ParentID:   parentIDCol,
	}
}()

var CategoriesProducts = schema.ManyToMany[
	CategoriesAlias, CategoriesColumnAlias, *CategoriesScanner,
	ProductCategoriesAlias, ProductCategoriesColumnAlias,
	ProductsAlias, ProductsColumnAlias, *ProductsScanner,
](
	CategoriesAliasName,
	ProductCategoriesRef,
	ProductsRef,
	CategoriesColumnCategoryID,
	ProductCategoriesColumnCategoryID,
	ProductCategoriesColumnProductID,
	ProductsColumnProductID,
)

var CategoriesRef schema.RelationTableAlias[CategoriesAlias] = Categories.Table

var Currency = func() CurrencyTable {
	codeCol := schema.CharColumn(CurrencyColumnCode, 3, ddl.WithPrimaryKey[CurrencyColumnAlias]())
	nameCol := schema.TextColumn(CurrencyColumnName, ddl.WithNotNull[CurrencyColumnAlias]())

	return CurrencyTable{
		Table: schema.NewTable[CurrencyAlias, CurrencyColumnAlias, *CurrencyScanner](
			CurrencyAliasName,
			func() *CurrencyScanner { return &CurrencyScanner{} },
			[]*ddl.ColumnDDL[CurrencyColumnAlias]{
				codeCol.DDL(),
				nameCol.DDL(),
			},
		),
		Code: codeCol,
		Name: nameCol,
	}
}()

var CurrencyRef schema.RelationTableAlias[CurrencyAlias] = Currency.Table

var OrderItems = func() OrderItemsTable {
	orderIDCol := schema.BigIntColumn(
		OrderItemsColumnOrderID,
		ddl.WithNotNull[OrderItemsColumnAlias](),
		ddl.WithReferences[OrderItemsColumnAlias]("orders", "order_id"),
		ddl.WithOnDelete[OrderItemsColumnAlias]("CASCADE"),
	)
	lineNoCol := schema.IntegerColumn(
		OrderItemsColumnLineNo,
		ddl.WithNotNull[OrderItemsColumnAlias](),
		ddl.WithCheck[OrderItemsColumnAlias]("line_no > 0"),
	)
	productIDCol := schema.BigIntColumn(
		OrderItemsColumnProductID,
		ddl.WithNotNull[OrderItemsColumnAlias](),
		ddl.WithReferences[OrderItemsColumnAlias]("products", "product_id"),
	)
	qtyCol := schema.IntegerColumn(
		OrderItemsColumnQty,
		ddl.WithNotNull[OrderItemsColumnAlias](),
		ddl.WithCheck[OrderItemsColumnAlias]("qty > 0"),
	)
	unitPriceCol := schema.NumericColumn(
		OrderItemsColumnUnitPrice,
		12, 2,
		ddl.WithNotNull[OrderItemsColumnAlias](),
	)

	return OrderItemsTable{
		Table: schema.NewTable[OrderItemsAlias, OrderItemsColumnAlias, *OrderItemsScanner](
			OrderItemsAliasName,
			func() *OrderItemsScanner { return &OrderItemsScanner{} },
			[]*ddl.ColumnDDL[OrderItemsColumnAlias]{
				orderIDCol.DDL(),
				lineNoCol.DDL(),
				productIDCol.DDL(),
				qtyCol.DDL(),
				unitPriceCol.DDL(),
			},
			ddl.WithUniqueColumns[OrderItemsAlias, OrderItemsColumnAlias]([]OrderItemsColumnAlias{
				OrderItemsColumnOrderID,
				OrderItemsColumnProductID,
			}),
			ddl.WithIndexes[OrderItemsAlias, OrderItemsColumnAlias](
				ddl.NewIndex[OrderItemsAlias, OrderItemsColumnAlias](
					string(OrderItemsIndexProduct),
					OrderItemsAliasName,
				).OnColumns(OrderItemsColumnProductID),
			),
		),
		OrderID:   orderIDCol,
		LineNo:    lineNoCol,
		ProductID: productIDCol,
		Qty:       qtyCol,
		UnitPrice: unitPriceCol,
	}
}()

var OrderItemsRef schema.RelationTableAlias[OrderItemsAlias] = OrderItems.Table

var Orders = func() OrdersTable {
	orderIDCol := schema.BigSerialColumn(OrdersColumnOrderID, ddl.WithPrimaryKey[OrdersColumnAlias]())
	userIDCol := schema.BigIntColumn(
		OrdersColumnUserID,
		ddl.WithNotNull[OrdersColumnAlias](),
		ddl.WithReferences[OrdersColumnAlias]("users", "user_id"),
	)
	statusCol := schema.TextColumn(
		OrdersColumnStatus,
		ddl.WithNotNull[OrdersColumnAlias](),
		ddl.WithCheck[OrdersColumnAlias]("status IN ('NEW', 'PAID', 'CANCELLED', 'SHIPPED')"),
	)
	currencyCol := schema.CharColumn(
		OrdersColumnCurrency,
		3,
		ddl.WithNotNull[OrdersColumnAlias](),
		ddl.WithReferences[OrdersColumnAlias]("currency", "code"),
	)
	createdAtCol := schema.TimestamptzColumn(
		OrdersColumnCreatedAt,
		ddl.WithNotNull[OrdersColumnAlias](),
		ddl.WithDefault[OrdersColumnAlias]("now()"),
	)
	updatedAtCol := schema.TimestamptzColumn(
		OrdersColumnUpdatedAt,
		ddl.WithNotNull[OrdersColumnAlias](),
		ddl.WithDefault[OrdersColumnAlias]("now()"),
	)

	return OrdersTable{
		Table: schema.NewTable[OrdersAlias, OrdersColumnAlias, *OrdersScanner](
			OrdersAliasName,
			func() *OrdersScanner { return &OrdersScanner{} },
			[]*ddl.ColumnDDL[OrdersColumnAlias]{
				orderIDCol.DDL(),
				userIDCol.DDL(),
				statusCol.DDL(),
				currencyCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
			},
			ddl.WithIndexes[OrdersAlias, OrdersColumnAlias](
				ddl.NewIndex[OrdersAlias, OrdersColumnAlias](
					string(OrdersIndexUserCreated),
					OrdersAliasName,
				).OnColumns(OrdersColumnUserID, OrdersColumnCreatedAtDesc),
			),
		),
		OrderID:   orderIDCol,
		UserID:    userIDCol,
		Status:    statusCol,
		Currency:  currencyCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
	}
}()

var OrdersCurrency = schema.BelongsTo[OrdersAlias, OrdersColumnAlias, *OrdersScanner, CurrencyAlias, CurrencyColumnAlias, *CurrencyScanner](
	OrdersAliasName,
	CurrencyRef,
	OrdersColumnCurrency,
	CurrencyColumnCode,
)

var OrdersRef schema.RelationTableAlias[OrdersAlias] = Orders.Table

var OrdersUser = schema.BelongsTo[OrdersAlias, OrdersColumnAlias, *OrdersScanner, UsersAlias, UsersColumnAlias, *UsersScanner](
	OrdersAliasName,
	UsersRef,
	OrdersColumnUserID,
	UsersColumnUserID,
)

var ProductCategories = func() ProductCategoriesTable {
	productIDCol := schema.BigIntColumn(
		ProductCategoriesColumnProductID,
		ddl.WithNotNull[ProductCategoriesColumnAlias](),
		ddl.WithReferences[ProductCategoriesColumnAlias]("products", "product_id"),
		ddl.WithOnDelete[ProductCategoriesColumnAlias]("CASCADE"),
	)
	categoryIDCol := schema.BigIntColumn(
		ProductCategoriesColumnCategoryID,
		ddl.WithNotNull[ProductCategoriesColumnAlias](),
		ddl.WithReferences[ProductCategoriesColumnAlias]("categories", "category_id"),
		ddl.WithOnDelete[ProductCategoriesColumnAlias]("CASCADE"),
	)

	return ProductCategoriesTable{
		Table: schema.NewTable[ProductCategoriesAlias, ProductCategoriesColumnAlias, *ProductCategoriesScanner](
			ProductCategoriesAliasName,
			func() *ProductCategoriesScanner { return &ProductCategoriesScanner{} },
			[]*ddl.ColumnDDL[ProductCategoriesColumnAlias]{
				productIDCol.DDL(),
				categoryIDCol.DDL(),
			},
			ddl.WithPrimaryKeyColumns[ProductCategoriesAlias, ProductCategoriesColumnAlias]([]ProductCategoriesColumnAlias{
				ProductCategoriesColumnProductID,
				ProductCategoriesColumnCategoryID,
			}),
		),
		ProductID:  productIDCol,
		CategoryID: categoryIDCol,
	}
}()

var ProductCategoriesRef schema.RelationTableAlias[ProductCategoriesAlias] = ProductCategories.Table

var ProductTags = func() ProductTagsTable {
	productIDCol := schema.BigIntColumn(
		ProductTagsColumnProductID,
		ddl.WithNotNull[ProductTagsColumnAlias](),
		ddl.WithReferences[ProductTagsColumnAlias]("products", "product_id"),
		ddl.WithOnDelete[ProductTagsColumnAlias]("CASCADE"),
	)
	tagIDCol := schema.BigIntColumn(
		ProductTagsColumnTagID,
		ddl.WithNotNull[ProductTagsColumnAlias](),
		ddl.WithReferences[ProductTagsColumnAlias]("tags", "tag_id"),
		ddl.WithOnDelete[ProductTagsColumnAlias]("CASCADE"),
	)

	return ProductTagsTable{
		Table: schema.NewTable[ProductTagsAlias, ProductTagsColumnAlias, *ProductTagsScanner](
			ProductTagsAliasName,
			func() *ProductTagsScanner { return &ProductTagsScanner{} },
			[]*ddl.ColumnDDL[ProductTagsColumnAlias]{
				productIDCol.DDL(),
				tagIDCol.DDL(),
			},
			ddl.WithPrimaryKeyColumns[ProductTagsAlias, ProductTagsColumnAlias]([]ProductTagsColumnAlias{
				ProductTagsColumnProductID,
				ProductTagsColumnTagID,
			}),
		),
		ProductID: productIDCol,
		TagID:     tagIDCol,
	}
}()

var ProductTagsRef schema.RelationTableAlias[ProductTagsAlias] = ProductTags.Table

var Products = func() ProductsTable {
	productIDCol := schema.BigSerialColumn(ProductsColumnProductID, ddl.WithPrimaryKey[ProductsColumnAlias]())
	skuCol := schema.TextColumn(
		ProductsColumnSKU,
		ddl.WithNotNull[ProductsColumnAlias](),
		ddl.WithUnique[ProductsColumnAlias](),
	)
	nameCol := schema.TextColumn(ProductsColumnName, ddl.WithNotNull[ProductsColumnAlias]())
	priceCol := schema.NumericColumn(ProductsColumnPrice, 12, 2, ddl.WithNotNull[ProductsColumnAlias]())
	currencyCol := schema.CharColumn(
		ProductsColumnCurrency,
		3,
		ddl.WithNotNull[ProductsColumnAlias](),
		ddl.WithReferences[ProductsColumnAlias]("currency", "code"),
	)
	stockQtyCol := schema.IntegerColumn(
		ProductsColumnStockQty,
		ddl.WithNotNull[ProductsColumnAlias](),
		ddl.WithDefault[ProductsColumnAlias]("0"),
		ddl.WithCheck[ProductsColumnAlias]("stock_qty >= 0"),
	)
	isDeletedCol := schema.BooleanColumn(
		ProductsColumnIsDeleted,
		ddl.WithNotNull[ProductsColumnAlias](),
		ddl.WithDefault[ProductsColumnAlias]("false"),
	)
	createdAtCol := schema.TimestamptzColumn(
		ProductsColumnCreatedAt,
		ddl.WithNotNull[ProductsColumnAlias](),
		ddl.WithDefault[ProductsColumnAlias]("now()"),
	)
	updatedAtCol := schema.TimestamptzColumn(
		ProductsColumnUpdatedAt,
		ddl.WithNotNull[ProductsColumnAlias](),
		ddl.WithDefault[ProductsColumnAlias]("now()"),
	)

	return ProductsTable{
		Table: schema.NewTable[ProductsAlias, ProductsColumnAlias, *ProductsScanner](
			ProductsAliasName,
			func() *ProductsScanner { return &ProductsScanner{} },
			[]*ddl.ColumnDDL[ProductsColumnAlias]{
				productIDCol.DDL(),
				skuCol.DDL(),
				nameCol.DDL(),
				priceCol.DDL(),
				currencyCol.DDL(),
				stockQtyCol.DDL(),
				isDeletedCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
			},
			ddl.WithIndexes[ProductsAlias, ProductsColumnAlias](
				ddl.NewIndex[ProductsAlias, ProductsColumnAlias](
					string(ProductsIndexNotDeleted),
					ProductsAliasName,
				).OnColumns(ProductsColumnProductID).Where("is_deleted = false"),
			),
		),
		ProductID: productIDCol,
		SKU:       skuCol,
		Name:      nameCol,
		Price:     priceCol,
		Currency:  currencyCol,
		StockQty:  stockQtyCol,
		IsDeleted: isDeletedCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
	}
}()

var ProductsCategories = schema.ManyToMany[
	ProductsAlias, ProductsColumnAlias, *ProductsScanner,
	ProductCategoriesAlias, ProductCategoriesColumnAlias,
	CategoriesAlias, CategoriesColumnAlias, *CategoriesScanner,
](
	ProductsAliasName,
	ProductCategoriesRef,
	CategoriesRef,
	ProductsColumnProductID,
	ProductCategoriesColumnProductID,
	ProductCategoriesColumnCategoryID,
	CategoriesColumnCategoryID,
)

var ProductsRef schema.RelationTableAlias[ProductsAlias] = Products.Table

var ProductsTags = schema.ManyToMany[
	ProductsAlias, ProductsColumnAlias, *ProductsScanner,
	ProductTagsAlias, ProductTagsColumnAlias,
	TagsAlias, TagsColumnAlias, *TagsScanner,
](
	ProductsAliasName,
	ProductTagsRef,
	TagsRef,
	ProductsColumnProductID,
	ProductTagsColumnProductID,
	ProductTagsColumnTagID,
	TagsColumnTagID,
)

var Tags = func() TagsTable {
	tagIDCol := schema.BigSerialColumn(TagsColumnTagID, ddl.WithPrimaryKey[TagsColumnAlias]())
	nameCol := schema.TextColumn(TagsColumnName, ddl.WithNotNull[TagsColumnAlias]())
	slugCol := schema.TextColumn(
		TagsColumnSlug,
		ddl.WithNotNull[TagsColumnAlias](),
		ddl.WithUnique[TagsColumnAlias](),
	)

	return TagsTable{
		Table: schema.NewTable[TagsAlias, TagsColumnAlias, *TagsScanner](
			TagsAliasName,
			func() *TagsScanner { return &TagsScanner{} },
			[]*ddl.ColumnDDL[TagsColumnAlias]{
				tagIDCol.DDL(),
				nameCol.DDL(),
				slugCol.DDL(),
			},
		),
		TagID: tagIDCol,
		Name:  nameCol,
		Slug:  slugCol,
	}
}()

var TagsProducts = schema.ManyToMany[
	TagsAlias, TagsColumnAlias, *TagsScanner,
	ProductTagsAlias, ProductTagsColumnAlias,
	ProductsAlias, ProductsColumnAlias, *ProductsScanner,
](
	TagsAliasName,
	ProductTagsRef,
	ProductsRef,
	TagsColumnTagID,
	ProductTagsColumnTagID,
	ProductTagsColumnProductID,
	ProductsColumnProductID,
)

var TagsRef schema.RelationTableAlias[TagsAlias] = Tags.Table

var Users = func() UsersTable {
	userIDCol := schema.BigSerialColumn(UsersColumnUserID, ddl.WithPrimaryKey[UsersColumnAlias]())
	emailCol := schema.TextColumn(
		UsersColumnEmail,
		ddl.WithNotNull[UsersColumnAlias](),
		ddl.WithUnique[UsersColumnAlias](),
	)
	fullNameCol := schema.TextColumn(UsersColumnFullName, ddl.WithNotNull[UsersColumnAlias]())
	isActiveCol := schema.BooleanColumn(
		UsersColumnIsActive,
		ddl.WithNotNull[UsersColumnAlias](),
		ddl.WithDefault[UsersColumnAlias]("true"),
	)
	createdAtCol := schema.TimestamptzColumn(
		UsersColumnCreatedAt,
		ddl.WithNotNull[UsersColumnAlias](),
		ddl.WithDefault[UsersColumnAlias]("now()"),
	)
	updatedAtCol := schema.TimestamptzColumn(
		UsersColumnUpdatedAt,
		ddl.WithNotNull[UsersColumnAlias](),
		ddl.WithDefault[UsersColumnAlias]("now()"),
	)

	return UsersTable{
		Table: schema.NewTable[UsersAlias, UsersColumnAlias, *UsersScanner](
			UsersAliasName,
			func() *UsersScanner { return &UsersScanner{} },
			[]*ddl.ColumnDDL[UsersColumnAlias]{
				userIDCol.DDL(),
				emailCol.DDL(),
				fullNameCol.DDL(),
				isActiveCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
			},
		),
		UserID:    userIDCol,
		Email:     emailCol,
		FullName:  fullNameCol,
		IsActive:  isActiveCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
	}
}()

var UsersOrders = schema.HasMany[UsersAlias, UsersColumnAlias, *UsersScanner, OrdersAlias, OrdersColumnAlias, *OrdersScanner](
	UsersAliasName,
	OrdersRef,
	OrdersColumnUserID,
	UsersColumnUserID,
)

var UsersRef schema.RelationTableAlias[UsersAlias] = Users.Table