storepb

package
v0.4.23 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Mar 31, 2026 License: Apache-2.0 Imports: 19 Imported by: 0

Documentation

Index

Constants

View Source 
const (
	CurrencyConstraintPkey                 = "currency_pkey"
	UserConstraintPkey                     = "users_pkey"
	UserConstraintEmailKey                 = "users_email_key"
	UserConstraintEmailIdx                 = "idx_users_email"
	ProfileConstraintPkey                  = "profiles_pkey"
	ProfileConstraintUserIdIdx             = "idx_profiles_user_id"
	CategoryConstraintPkey                 = "categories_pkey"
	CategoryConstraintSlugKey              = "categories_slug_key"
	TagConstraintPkey                      = "tags_pkey"
	TagConstraintSlugKey                   = "tags_slug_key"
	ProductConstraintPkey                  = "products_pkey"
	ProductConstraintSkuKey                = "products_sku_key"
	ProductConstraintCheck                 = "products_check"
	OrderConstraintPkey                    = "orders_pkey"
	OrderConstraintCheck                   = "orders_check"
	OrderItemConstraintOrderIdProductIdKey = "order_items_order_id_product_id_key"
	OrderItemConstraintPkey                = "order_items_pkey"
	OrderItemConstraintCheck               = "order_items_check"
	OrderItemConstraintCheck1              = "order_items_check1"
	UserSettingsConstraintPkey             = "user_settings_pkey"
	AuditLogConstraintPkey                 = "audit_logs_pkey"
	UserPreferencesConstraintPkey          = "user_preferences_pkey"
)

Variables

View Source 
var (
	AuditSeverity_name = map[int32]string{
		0: "AUDIT_SEVERITY_UNSPECIFIED",
		1: "AUDIT_SEVERITY_LOW",
		2: "AUDIT_SEVERITY_MEDIUM",
		3: "AUDIT_SEVERITY_HIGH",
		4: "AUDIT_SEVERITY_CRITICAL",
	}
	AuditSeverity_value = map[string]int32{
		"AUDIT_SEVERITY_UNSPECIFIED": 0,
		"AUDIT_SEVERITY_LOW":         1,
		"AUDIT_SEVERITY_MEDIUM":      2,
		"AUDIT_SEVERITY_HIGH":        3,
		"AUDIT_SEVERITY_CRITICAL":    4,
	}
)

Enum value maps for AuditSeverity.

View Source 
var (
	ErrCurrencyPrimaryKey              = errors.New("primary key constraint violated: currency_pkey")
	ErrUserPrimaryKey                  = errors.New("primary key constraint violated: users_pkey")
	ErrUserEmailUnique                 = errors.New("unique constraint violated: users_email_key")
	ErrUserEmailUniqueIdx              = errors.New("unique constraint violated: idx_users_email")
	ErrProfilePrimaryKey               = errors.New("primary key constraint violated: profiles_pkey")
	ErrProfileUserIdUniqueIdx          = errors.New("unique constraint violated: idx_profiles_user_id")
	ErrCategoryPrimaryKey              = errors.New("primary key constraint violated: categories_pkey")
	ErrCategorySlugUnique              = errors.New("unique constraint violated: categories_slug_key")
	ErrTagPrimaryKey                   = errors.New("primary key constraint violated: tags_pkey")
	ErrTagSlugUnique                   = errors.New("unique constraint violated: tags_slug_key")
	ErrProductPrimaryKey               = errors.New("primary key constraint violated: products_pkey")
	ErrProductSkuUnique                = errors.New("unique constraint violated: products_sku_key")
	ErrProductCheck                    = errors.New("check constraint violated: products_check")
	ErrOrderPrimaryKey                 = errors.New("primary key constraint violated: orders_pkey")
	ErrOrderCheck                      = errors.New("check constraint violated: orders_check")
	ErrOrderItemOrderIdProductIdUnique = errors.New("unique constraint violated: order_items_order_id_product_id_key")
	ErrOrderItemPrimaryKey             = errors.New("primary key constraint violated: order_items_pkey")
	ErrOrderItemCheck                  = errors.New("check constraint violated: order_items_check")
	ErrOrderItemCheck1                 = errors.New("check constraint violated: order_items_check1")
	ErrUserSettingsPrimaryKey          = errors.New("primary key constraint violated: user_settings_pkey")
	ErrAuditLogPrimaryKey              = errors.New("primary key constraint violated: audit_logs_pkey")
	ErrUserPreferencesPrimaryKey       = errors.New("primary key constraint violated: user_preferences_pkey")
)
View Source 
var AdditionalSQL = []ddl.SchemaSqler{
	ddl.RawSQL("CREATE EXTENSION IF NOT EXISTS pg_trgm"),
	ddl.RawSQL("CREATE OR REPLACE FUNCTION store.set_updated_at() RETURNS trigger LANGUAGE plpgsql AS $$ BEGIN NEW.updated_at = now(); RETURN NEW; END; $$"),
}

AdditionalSQL contains raw SQL statements declared via additional_code file option. Pass these to ddl.SchemaSQL() alongside table definitions.

View Source 
var AuditLogConverter = repository.Converter[*AuditLogScanner, *AuditLog]{
	ToScanner: (*AuditLog).IntoPlain,
	ToProto:   (*AuditLogScanner).IntoPb,
}

AuditLogConverter provides conversion between AuditLog and AuditLogScanner

View Source 
var AuditLogs = func() AuditLogsTable {
	createActionCreateActionCol := schema.NullJSONBColumn(AuditLogColumnCreateActionCreateAction)
	deleteActionDeleteActionCol := schema.NullJSONBColumn(AuditLogColumnDeleteActionDeleteAction)
	detailCaseCol := schema.TextColumn(AuditLogColumnDetailCase, ddl.WithNotNull[AuditLogColumnAlias]())
	idCol := schema.BigSerialColumn(AuditLogColumnId, ddl.WithPrimaryKey[AuditLogColumnAlias]())
	actionCol := schema.TextColumn(AuditLogColumnAction, ddl.WithNotNull[AuditLogColumnAlias]())
	entityTypeCol := schema.TextColumn(AuditLogColumnEntityType, ddl.WithNotNull[AuditLogColumnAlias]())
	entityIdCol := schema.BigIntColumn(AuditLogColumnEntityId, ddl.WithNotNull[AuditLogColumnAlias]())
	tagsCol := schema.TextArrayColumn(AuditLogColumnTags, ddl.WithNotNull[AuditLogColumnAlias]())
	relatedIdsCol := schema.BigIntArrayColumn(AuditLogColumnRelatedIds, ddl.WithNotNull[AuditLogColumnAlias]())
	severityCol := schema.TextColumn(AuditLogColumnSeverity, ddl.WithNotNull[AuditLogColumnAlias]())
	affectedLevelsCol := schema.TextArrayColumn(AuditLogColumnAffectedLevels, ddl.WithNotNull[AuditLogColumnAlias]())
	dbCreatedAtCol := schema.TimestamptzColumn(AuditLogColumnDbCreatedAt, ddl.WithDefault[AuditLogColumnAlias]("now()"), ddl.WithNotNull[AuditLogColumnAlias]())
	dbUpdatedAtCol := schema.TimestamptzColumn(AuditLogColumnDbUpdatedAt, ddl.WithDefault[AuditLogColumnAlias]("now()"), ddl.WithNotNull[AuditLogColumnAlias]())

	return AuditLogsTable{
		Table: schema.NewTable[AuditLogAlias, AuditLogColumnAlias, *AuditLogScanner](
			AuditLogAliasName,
			func() *AuditLogScanner { return &AuditLogScanner{} },
			[]*ddl.ColumnDDL[AuditLogColumnAlias]{
				createActionCreateActionCol.DDL(),
				deleteActionDeleteActionCol.DDL(),
				detailCaseCol.DDL(),
				idCol.DDL(),
				actionCol.DDL(),
				entityTypeCol.DDL(),
				entityIdCol.DDL(),
				tagsCol.DDL(),
				relatedIdsCol.DDL(),
				severityCol.DDL(),
				affectedLevelsCol.DDL(),
				dbCreatedAtCol.DDL(),
				dbUpdatedAtCol.DDL(),
			},
			ddl.WithSchema[AuditLogAlias, AuditLogColumnAlias]("store"),
		),
		CreateActionCreateAction: createActionCreateActionCol,
		DeleteActionDeleteAction: deleteActionDeleteActionCol,
		DetailCase:               detailCaseCol,
		Id:                       idCol,
		Action:                   actionCol,
		EntityType:               entityTypeCol,
		EntityId:                 entityIdCol,
		Tags:                     tagsCol,
		RelatedIds:               relatedIdsCol,
		Severity:                 severityCol,
		AffectedLevels:           affectedLevelsCol,
		DbCreatedAt:              dbCreatedAtCol,
		DbUpdatedAt:              dbUpdatedAtCol,
	}
}()

AuditLogs is the global audit_logs table instance

View Source 
var AuditLogsRef schema.RelationTableAlias[AuditLogAlias] = AuditLogs.Table

AuditLogsRef is a reference to the audit_logs table for relations

View Source 
var CategoryConverter = repository.Converter[*CategoryScanner, *Category]{
	ToScanner: (*Category).IntoPlain,
	ToProto:   (*CategoryScanner).IntoPb,
}

CategoryConverter provides conversion between Category and CategoryScanner

View Source 
var Categorys = func() CategorysTable {
	idCol := schema.BigSerialColumn(CategoryColumnId, ddl.WithPrimaryKey[CategoryColumnAlias]())
	createdAtCol := schema.TimestamptzColumn(CategoryColumnCreatedAt, ddl.WithDefault[CategoryColumnAlias]("now()"), ddl.WithNotNull[CategoryColumnAlias]())
	updatedAtCol := schema.TimestamptzColumn(CategoryColumnUpdatedAt, ddl.WithDefault[CategoryColumnAlias]("now()"), ddl.WithNotNull[CategoryColumnAlias]())
	nameCol := schema.TextColumn(CategoryColumnName, ddl.WithNotNull[CategoryColumnAlias]())
	slugCol := schema.TextColumn(CategoryColumnSlug, ddl.WithUnique[CategoryColumnAlias](), ddl.WithNotNull[CategoryColumnAlias]())
	parentIdCol := schema.NullBigIntColumn(CategoryColumnParentId, ddl.WithReferences[CategoryColumnAlias]("\"store\".\"categories\"", "id"), ddl.WithOnDelete[CategoryColumnAlias]("SET NULL"))

	return CategorysTable{
		Table: schema.NewTable[CategoryAlias, CategoryColumnAlias, *CategoryScanner](
			CategoryAliasName,
			func() *CategoryScanner { return &CategoryScanner{} },
			[]*ddl.ColumnDDL[CategoryColumnAlias]{
				idCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
				nameCol.DDL(),
				slugCol.DDL(),
				parentIdCol.DDL(),
			},
			ddl.WithSchema[CategoryAlias, CategoryColumnAlias]("store"),
		),
		Id:        idCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
		Name:      nameCol,
		Slug:      slugCol,
		ParentId:  parentIdCol,
	}
}()

Categorys is the global categories table instance

View Source 
var CategorysRef schema.RelationTableAlias[CategoryAlias] = Categorys.Table

CategorysRef is a reference to the categories table for relations

View Source 
var CurrencyConverter = repository.Converter[*CurrencyScanner, *Currency]{
	ToScanner: (*Currency).IntoPlain,
	ToProto:   (*CurrencyScanner).IntoPb,
}

CurrencyConverter provides conversion between Currency and CurrencyScanner

View Source 
var Currencys = func() CurrencysTable {
	codeCol := schema.TextColumn(CurrencyColumnCode, ddl.WithPrimaryKey[CurrencyColumnAlias](), ddl.WithCheck[CurrencyColumnAlias]("code <> ''"))
	nameCol := schema.TextColumn(CurrencyColumnName, ddl.WithNotNull[CurrencyColumnAlias]())

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

Currencys is the global currency table instance

View Source 
var CurrencysRef schema.RelationTableAlias[CurrencyAlias] = Currencys.Table

CurrencysRef is a reference to the currency table for relations

View Source 
var File_examples_proto_store_proto protoreflect.FileDescriptor
View Source 
var OrderConverter = repository.Converter[*OrderScanner, *Order]{
	ToScanner: (*Order).IntoPlain,
	ToProto:   (*OrderScanner).IntoPb,
}

OrderConverter provides conversion between Order and OrderScanner

View Source 
var OrderCurrency = schema.BelongsTo[
	OrderAlias, OrderColumnAlias, *OrderScanner,
	CurrencyAlias, CurrencyColumnAlias, *CurrencyScanner,
](
	OrderAliasName,
	CurrencysRef,
	OrderColumnCurrency,
	CurrencyColumnCode,
)

OrderCurrency defines the belongs-to relationship: Order belongs to Currency

View Source 
var OrderItemConverter = repository.Converter[*OrderItemScanner, *OrderItem]{
	ToScanner: (*OrderItem).IntoPlain,
	ToProto:   (*OrderItemScanner).IntoPb,
}

OrderItemConverter provides conversion between OrderItem and OrderItemScanner

View Source 
var OrderItemOrder = schema.BelongsTo[
	OrderItemAlias, OrderItemColumnAlias, *OrderItemScanner,
	OrderAlias, OrderColumnAlias, *OrderScanner,
](
	OrderItemAliasName,
	OrdersRef,
	OrderItemColumnOrderId,
	OrderColumnId,
)

OrderItemOrder defines the belongs-to relationship: OrderItem belongs to Order

View Source 
var OrderItemProduct = schema.BelongsTo[
	OrderItemAlias, OrderItemColumnAlias, *OrderItemScanner,
	ProductAlias, ProductColumnAlias, *ProductScanner,
](
	OrderItemAliasName,
	ProductsRef,
	OrderItemColumnProductId,
	ProductColumnId,
)

OrderItemProduct defines the belongs-to relationship: OrderItem belongs to Product

View Source 
var OrderItems = func() OrderItemsTable {
	orderIdCol := schema.BigIntColumn(OrderItemColumnOrderId, ddl.WithReferences[OrderItemColumnAlias]("\"store\".\"orders\"", "id"), ddl.WithOnDelete[OrderItemColumnAlias]("CASCADE"), ddl.WithNotNull[OrderItemColumnAlias]())
	lineNoCol := schema.IntegerColumn(OrderItemColumnLineNo, ddl.WithNotNull[OrderItemColumnAlias]())
	productIdCol := schema.BigIntColumn(OrderItemColumnProductId, ddl.WithReferences[OrderItemColumnAlias]("\"store\".\"products\"", "id"), ddl.WithOnDelete[OrderItemColumnAlias]("RESTRICT"), ddl.WithNotNull[OrderItemColumnAlias]())
	qtyCol := schema.IntegerColumn(OrderItemColumnQty, ddl.WithNotNull[OrderItemColumnAlias]())
	unitPriceCol := schema.DoublePrecisionColumn(OrderItemColumnUnitPrice, ddl.WithNotNull[OrderItemColumnAlias]())

	return OrderItemsTable{
		Table: schema.NewTable[OrderItemAlias, OrderItemColumnAlias, *OrderItemScanner](
			OrderItemAliasName,
			func() *OrderItemScanner { return &OrderItemScanner{} },
			[]*ddl.ColumnDDL[OrderItemColumnAlias]{
				orderIdCol.DDL(),
				lineNoCol.DDL(),
				productIdCol.DDL(),
				qtyCol.DDL(),
				unitPriceCol.DDL(),
			},
			ddl.WithUniqueColumns[OrderItemAlias, OrderItemColumnAlias](
				[]OrderItemColumnAlias{OrderItemColumnOrderId, OrderItemColumnProductId},
			),
			ddl.WithPrimaryKeyColumns[OrderItemAlias, OrderItemColumnAlias]([]OrderItemColumnAlias{OrderItemColumnOrderId, OrderItemColumnLineNo}),
			ddl.WithSchema[OrderItemAlias, OrderItemColumnAlias]("store"),
			ddl.WithPostStatements[OrderItemAlias, OrderItemColumnAlias](
				"ALTER TABLE {table} ENABLE ROW LEVEL SECURITY",
				"CREATE POLICY order_items_own_data ON {table} FOR ALL USING (order_id IN (SELECT o.id FROM \"store\".\"orders\" o WHERE o.user_id = current_setting('app.current_user_id')::bigint))",
			),
		),
		OrderId:   orderIdCol,
		LineNo:    lineNoCol,
		ProductId: productIdCol,
		Qty:       qtyCol,
		UnitPrice: unitPriceCol,
	}
}()

OrderItems is the global order_items table instance

View Source 
var OrderItemsRef schema.RelationTableAlias[OrderItemAlias] = OrderItems.Table

OrderItemsRef is a reference to the order_items table for relations

View Source 
var OrderOrderItems = schema.HasMany[
	OrderAlias, OrderColumnAlias, *OrderScanner,
	OrderItemAlias, OrderItemColumnAlias, *OrderItemScanner,
](
	OrderAliasName,
	OrderItemsRef,
	OrderItemColumnOrderId,
	OrderColumnId,
)

OrderOrderItems defines the one-to-many relationship: Order has many OrderItem

View Source 
var OrderUser = schema.BelongsTo[
	OrderAlias, OrderColumnAlias, *OrderScanner,
	UserAlias, UserColumnAlias, *UserScanner,
](
	OrderAliasName,
	UsersRef,
	OrderColumnUserId,
	UserColumnId,
)

OrderUser defines the belongs-to relationship: Order belongs to User

View Source 
var Orders = func() OrdersTable {
	idCol := schema.BigSerialColumn(OrderColumnId, ddl.WithPrimaryKey[OrderColumnAlias]())
	createdAtCol := schema.TimestamptzColumn(OrderColumnCreatedAt, ddl.WithDefault[OrderColumnAlias]("now()"), ddl.WithNotNull[OrderColumnAlias]())
	updatedAtCol := schema.TimestamptzColumn(OrderColumnUpdatedAt, ddl.WithDefault[OrderColumnAlias]("now()"), ddl.WithNotNull[OrderColumnAlias]())
	userIdCol := schema.BigIntColumn(OrderColumnUserId, ddl.WithReferences[OrderColumnAlias]("\"store\".\"users\"", "id"), ddl.WithOnDelete[OrderColumnAlias]("CASCADE"), ddl.WithNotNull[OrderColumnAlias]())
	statusCol := schema.TextColumn(OrderColumnStatus, ddl.WithDefault[OrderColumnAlias]("'NEW'"), ddl.WithNotNull[OrderColumnAlias]())
	currencyCol := schema.TextColumn(OrderColumnCurrency, ddl.WithReferences[OrderColumnAlias]("currency", "code"), ddl.WithOnDelete[OrderColumnAlias]("RESTRICT"), ddl.WithNotNull[OrderColumnAlias]())

	idx0 := ddl.NewIndex[OrderAlias, OrderColumnAlias]("idx_orders_user_id", OrderAliasName).OnColumns(OrderColumnUserId)
	idx1 := ddl.NewIndex[OrderAlias, OrderColumnAlias]("idx_orders_status", OrderAliasName).OnColumns(OrderColumnStatus)
	idx2 := ddl.NewIndex[OrderAlias, OrderColumnAlias]("idx_orders_created_at", OrderAliasName).OnColumns(OrderColumnCreatedAt)

	return OrdersTable{
		Table: schema.NewTable[OrderAlias, OrderColumnAlias, *OrderScanner](
			OrderAliasName,
			func() *OrderScanner { return &OrderScanner{} },
			[]*ddl.ColumnDDL[OrderColumnAlias]{
				idCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
				userIdCol.DDL(),
				statusCol.DDL(),
				currencyCol.DDL(),
			},
			ddl.WithIndexes[OrderAlias, OrderColumnAlias](
				idx0,
				idx1,
				idx2,
			),
			ddl.WithSchema[OrderAlias, OrderColumnAlias]("store"),
			ddl.WithPostStatements[OrderAlias, OrderColumnAlias](
				"ALTER TABLE {table} ENABLE ROW LEVEL SECURITY",
				"CREATE POLICY orders_own_data ON {table} FOR ALL USING (user_id = current_setting('app.current_user_id')::bigint)",
			),
		),
		Id:        idCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
		UserId:    userIdCol,
		Status:    statusCol,
		Currency:  currencyCol,
	}
}()

Orders is the global orders table instance

View Source 
var OrdersRef schema.RelationTableAlias[OrderAlias] = Orders.Table

OrdersRef is a reference to the orders table for relations

View Source 
var ProductConverter = repository.Converter[*ProductScanner, *Product]{
	ToScanner: (*Product).IntoPlain,
	ToProto:   (*ProductScanner).IntoPb,
}

ProductConverter provides conversion between Product and ProductScanner

View Source 
var Products = func() ProductsTable {
	idCol := schema.BigSerialColumn(ProductColumnId, ddl.WithPrimaryKey[ProductColumnAlias]())
	createdAtCol := schema.TimestamptzColumn(ProductColumnCreatedAt, ddl.WithDefault[ProductColumnAlias]("now()"), ddl.WithNotNull[ProductColumnAlias]())
	updatedAtCol := schema.TimestamptzColumn(ProductColumnUpdatedAt, ddl.WithDefault[ProductColumnAlias]("now()"), ddl.WithNotNull[ProductColumnAlias]())
	skuCol := schema.TextColumn(ProductColumnSku, ddl.WithUnique[ProductColumnAlias](), ddl.WithNotNull[ProductColumnAlias]())
	nameCol := schema.TextColumn(ProductColumnName, ddl.WithNotNull[ProductColumnAlias]())
	priceCol := schema.DoublePrecisionColumn(ProductColumnPrice, ddl.WithNotNull[ProductColumnAlias]())
	currencyCol := schema.TextColumn(ProductColumnCurrency, ddl.WithReferences[ProductColumnAlias]("currency", "code"), ddl.WithOnDelete[ProductColumnAlias]("RESTRICT"), ddl.WithNotNull[ProductColumnAlias]())
	stockQtyCol := schema.IntegerColumn(ProductColumnStockQty, ddl.WithDefault[ProductColumnAlias]("0"), ddl.WithNotNull[ProductColumnAlias]())
	isDeletedCol := schema.BooleanColumn(ProductColumnIsDeleted, ddl.WithDefault[ProductColumnAlias]("false"), ddl.WithNotNull[ProductColumnAlias]())

	idx0 := ddl.NewIndex[ProductAlias, ProductColumnAlias]("idx_products_sku", ProductAliasName).OnColumns(ProductColumnSku)
	idx1 := ddl.NewIndex[ProductAlias, ProductColumnAlias]("idx_products_currency", ProductAliasName).OnColumns(ProductColumnCurrency)
	idx2 := ddl.NewIndex[ProductAlias, ProductColumnAlias]("idx_products_is_deleted_created_at", ProductAliasName).OnColumns(ProductColumnIsDeleted, ProductColumnCreatedAt)
	idx2 = idx2.Where("is_deleted = false")

	return ProductsTable{
		Table: schema.NewTable[ProductAlias, ProductColumnAlias, *ProductScanner](
			ProductAliasName,
			func() *ProductScanner { return &ProductScanner{} },
			[]*ddl.ColumnDDL[ProductColumnAlias]{
				idCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
				skuCol.DDL(),
				nameCol.DDL(),
				priceCol.DDL(),
				currencyCol.DDL(),
				stockQtyCol.DDL(),
				isDeletedCol.DDL(),
			},
			ddl.WithIndexes[ProductAlias, ProductColumnAlias](
				idx0,
				idx1,
				idx2,
			),
			ddl.WithSchema[ProductAlias, ProductColumnAlias]("store"),
		),
		Id:        idCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
		Sku:       skuCol,
		Name:      nameCol,
		Price:     priceCol,
		Currency:  currencyCol,
		StockQty:  stockQtyCol,
		IsDeleted: isDeletedCol,
	}
}()

Products is the global products table instance

View Source 
var ProductsRef schema.RelationTableAlias[ProductAlias] = Products.Table

ProductsRef is a reference to the products table for relations

View Source 
var ProfileConverter = repository.Converter[*ProfileScanner, *Profile]{
	ToScanner: (*Profile).IntoPlain,
	ToProto:   (*ProfileScanner).IntoPb,
}

ProfileConverter provides conversion between Profile and ProfileScanner

View Source 
var ProfileUser = schema.BelongsTo[
	ProfileAlias, ProfileColumnAlias, *ProfileScanner,
	UserAlias, UserColumnAlias, *UserScanner,
](
	ProfileAliasName,
	UsersRef,
	ProfileColumnUserId,
	UserColumnId,
)

ProfileUser defines the belongs-to relationship: Profile belongs to User

View Source 
var Profiles = func() ProfilesTable {
	idCol := schema.BigSerialColumn(ProfileColumnId, ddl.WithPrimaryKey[ProfileColumnAlias]())
	createdAtCol := schema.TimestamptzColumn(ProfileColumnCreatedAt, ddl.WithDefault[ProfileColumnAlias]("now()"), ddl.WithNotNull[ProfileColumnAlias]())
	updatedAtCol := schema.TimestamptzColumn(ProfileColumnUpdatedAt, ddl.WithDefault[ProfileColumnAlias]("now()"), ddl.WithNotNull[ProfileColumnAlias]())
	userIdCol := schema.BigIntColumn(ProfileColumnUserId, ddl.WithReferences[ProfileColumnAlias]("\"store\".\"users\"", "id"), ddl.WithOnDelete[ProfileColumnAlias]("CASCADE"), ddl.WithNotNull[ProfileColumnAlias]())
	bioCol := schema.TextColumn(ProfileColumnBio, ddl.WithNotNull[ProfileColumnAlias]())
	avatarUrlCol := schema.TextColumn(ProfileColumnAvatarUrl, ddl.WithNotNull[ProfileColumnAlias]())

	idx0 := ddl.NewIndex[ProfileAlias, ProfileColumnAlias]("idx_profiles_user_id", ProfileAliasName).OnColumns(ProfileColumnUserId)
	idx0 = idx0.Unique()

	return ProfilesTable{
		Table: schema.NewTable[ProfileAlias, ProfileColumnAlias, *ProfileScanner](
			ProfileAliasName,
			func() *ProfileScanner { return &ProfileScanner{} },
			[]*ddl.ColumnDDL[ProfileColumnAlias]{
				idCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
				userIdCol.DDL(),
				bioCol.DDL(),
				avatarUrlCol.DDL(),
			},
			ddl.WithIndexes[ProfileAlias, ProfileColumnAlias](
				idx0,
			),
			ddl.WithSchema[ProfileAlias, ProfileColumnAlias]("store"),
			ddl.WithPostStatements[ProfileAlias, ProfileColumnAlias](
				"ALTER TABLE {table} ENABLE ROW LEVEL SECURITY",
				"CREATE POLICY profiles_own_data ON {table} FOR ALL USING (user_id = current_setting('app.current_user_id')::bigint)",
			),
		),
		Id:        idCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
		UserId:    userIdCol,
		Bio:       bioCol,
		AvatarUrl: avatarUrlCol,
	}
}()

Profiles is the global profiles table instance

View Source 
var ProfilesRef schema.RelationTableAlias[ProfileAlias] = Profiles.Table

ProfilesRef is a reference to the profiles table for relations

View Source 
var TagConverter = repository.Converter[*TagScanner, *Tag]{
	ToScanner: (*Tag).IntoPlain,
	ToProto:   (*TagScanner).IntoPb,
}

TagConverter provides conversion between Tag and TagScanner

View Source 
var Tags = func() TagsTable {
	idCol := schema.BigSerialColumn(TagColumnId, ddl.WithPrimaryKey[TagColumnAlias]())
	createdAtCol := schema.TimestamptzColumn(TagColumnCreatedAt, ddl.WithDefault[TagColumnAlias]("now()"), ddl.WithNotNull[TagColumnAlias]())
	updatedAtCol := schema.TimestamptzColumn(TagColumnUpdatedAt, ddl.WithDefault[TagColumnAlias]("now()"), ddl.WithNotNull[TagColumnAlias]())
	nameCol := schema.TextColumn(TagColumnName, ddl.WithNotNull[TagColumnAlias]())
	slugCol := schema.TextColumn(TagColumnSlug, ddl.WithUnique[TagColumnAlias](), ddl.WithNotNull[TagColumnAlias]())

	return TagsTable{
		Table: schema.NewTable[TagAlias, TagColumnAlias, *TagScanner](
			TagAliasName,
			func() *TagScanner { return &TagScanner{} },
			[]*ddl.ColumnDDL[TagColumnAlias]{
				idCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
				nameCol.DDL(),
				slugCol.DDL(),
			},
		),
		Id:        idCol,
		CreatedAt: createdAtCol,
		UpdatedAt: updatedAtCol,
		Name:      nameCol,
		Slug:      slugCol,
	}
}()

Tags is the global tags table instance

View Source 
var TagsRef schema.RelationTableAlias[TagAlias] = Tags.Table

TagsRef is a reference to the tags table for relations

View Source 
var UserConverter = repository.Converter[*UserScanner, *User]{
	ToScanner: (*User).IntoPlain,
	ToProto:   (*UserScanner).IntoPb,
}

UserConverter provides conversion between User and UserScanner

View Source 
var UserOrders = schema.HasMany[
	UserAlias, UserColumnAlias, *UserScanner,
	OrderAlias, OrderColumnAlias, *OrderScanner,
](
	UserAliasName,
	OrdersRef,
	OrderColumnUserId,
	UserColumnId,
)

UserOrders defines the one-to-many relationship: User has many Order

View Source 
var UserPreferencesConverter = repository.Converter[*UserPreferencesScanner, *UserPreferences]{
	ToScanner: (*UserPreferences).IntoPlain,
	ToProto:   (*UserPreferencesScanner).IntoPb,
}

UserPreferencesConverter provides conversion between UserPreferences and UserPreferencesScanner

View Source 
var UserPreferencess = func() UserPreferencessTable {
	idCol := schema.BigSerialColumn(UserPreferencesColumnId, ddl.WithPrimaryKey[UserPreferencesColumnAlias]())
	userIdCol := schema.BigIntColumn(UserPreferencesColumnUserId, ddl.WithNotNull[UserPreferencesColumnAlias]())
	selectedThemeCol := schema.TextColumn(UserPreferencesColumnSelectedTheme, ddl.WithNotNull[UserPreferencesColumnAlias]())
	fallbackThemeCol := schema.TextColumn(UserPreferencesColumnFallbackTheme, ddl.WithNotNull[UserPreferencesColumnAlias]())

	return UserPreferencessTable{
		Table: schema.NewTable[UserPreferencesAlias, UserPreferencesColumnAlias, *UserPreferencesScanner](
			UserPreferencesAliasName,
			func() *UserPreferencesScanner { return &UserPreferencesScanner{} },
			[]*ddl.ColumnDDL[UserPreferencesColumnAlias]{
				idCol.DDL(),
				userIdCol.DDL(),
				selectedThemeCol.DDL(),
				fallbackThemeCol.DDL(),
			},
			ddl.WithSchema[UserPreferencesAlias, UserPreferencesColumnAlias]("store"),
		),
		Id:            idCol,
		UserId:        userIdCol,
		SelectedTheme: selectedThemeCol,
		FallbackTheme: fallbackThemeCol,
	}
}()

UserPreferencess is the global user_preferences table instance

View Source 
var UserPreferencessRef schema.RelationTableAlias[UserPreferencesAlias] = UserPreferencess.Table

UserPreferencessRef is a reference to the user_preferences table for relations

View Source 
var UserProfile = schema.HasOne[
	UserAlias, UserColumnAlias, *UserScanner,
	ProfileAlias, ProfileColumnAlias, *ProfileScanner,
](
	UserAliasName,
	ProfilesRef,
	ProfileColumnUserId,
	UserColumnId,
)

UserProfile defines the one-to-one relationship: User has one Profile

View Source 
var UserSettingsConverter = repository.Converter[*UserSettingsScanner, *UserSettings]{
	ToScanner: (*UserSettings).IntoPlain,
	ToProto:   (*UserSettingsScanner).IntoPb,
}

UserSettingsConverter provides conversion between UserSettings and UserSettingsScanner

View Source 
var UserSettingss = func() UserSettingssTable {
	idCol := schema.BigSerialColumn(UserSettingsColumnId, ddl.WithPrimaryKey[UserSettingsColumnAlias]())
	userIdCol := schema.BigIntColumn(UserSettingsColumnUserId, ddl.WithReferences[UserSettingsColumnAlias]("\"store\".\"users\"", "id"), ddl.WithOnDelete[UserSettingsColumnAlias]("CASCADE"), ddl.WithNotNull[UserSettingsColumnAlias]())
	themeCol := schema.TextColumn(UserSettingsColumnTheme, ddl.WithNotNull[UserSettingsColumnAlias]())

	return UserSettingssTable{
		Table: schema.NewTable[UserSettingsAlias, UserSettingsColumnAlias, *UserSettingsScanner](
			UserSettingsAliasName,
			func() *UserSettingsScanner { return &UserSettingsScanner{} },
			[]*ddl.ColumnDDL[UserSettingsColumnAlias]{
				idCol.DDL(),
				userIdCol.DDL(),
				themeCol.DDL(),
			},
			ddl.WithSchema[UserSettingsAlias, UserSettingsColumnAlias]("store"),
		),
		Id:     idCol,
		UserId: userIdCol,
		Theme:  themeCol,
	}
}()

UserSettingss is the global user_settings table instance

View Source 
var UserSettingssRef schema.RelationTableAlias[UserSettingsAlias] = UserSettingss.Table

UserSettingssRef is a reference to the user_settings table for relations

View Source 
var Users = func() UsersTable {
	idCol := schema.BigSerialColumn(UserColumnId, ddl.WithPrimaryKey[UserColumnAlias]())
	createdAtCol := schema.TimestamptzColumn(UserColumnCreatedAt, ddl.WithDefault[UserColumnAlias]("now()"), ddl.WithNotNull[UserColumnAlias]())
	updatedAtCol := schema.TimestamptzColumn(UserColumnUpdatedAt, ddl.WithDefault[UserColumnAlias]("now()"), ddl.WithNotNull[UserColumnAlias]())
	emailCol := schema.TextColumn(UserColumnEmail, ddl.WithUnique[UserColumnAlias](), ddl.WithNotNull[UserColumnAlias]())
	fullNameCol := schema.TextColumn(UserColumnFullName, ddl.WithNotNull[UserColumnAlias]())
	isActiveCol := schema.BooleanColumn(UserColumnIsActive, ddl.WithDefault[UserColumnAlias]("true"), ddl.WithNotNull[UserColumnAlias]())
	emailConfirmedAtCol := schema.NullTimestamptzColumn(UserColumnEmailConfirmedAt)
	nicknameCol := schema.NullTextColumn(UserColumnNickname)
	deletedAtCol := schema.NullTimestamptzColumn(UserColumnDeletedAt)

	idx0 := ddl.NewIndex[UserAlias, UserColumnAlias]("idx_users_email", UserAliasName).OnColumns(UserColumnEmail)
	idx0 = idx0.Unique()
	idx1 := ddl.NewIndex[UserAlias, UserColumnAlias]("idx_users_is_active_created_at", UserAliasName).OnColumns(UserColumnIsActive, UserColumnCreatedAt)

	return UsersTable{
		Table: schema.NewTable[UserAlias, UserColumnAlias, *UserScanner](
			UserAliasName,
			func() *UserScanner { return &UserScanner{} },
			[]*ddl.ColumnDDL[UserColumnAlias]{
				idCol.DDL(),
				createdAtCol.DDL(),
				updatedAtCol.DDL(),
				emailCol.DDL(),
				fullNameCol.DDL(),
				isActiveCol.DDL(),
				emailConfirmedAtCol.DDL(),
				nicknameCol.DDL(),
				deletedAtCol.DDL(),
			},
			ddl.WithIndexes[UserAlias, UserColumnAlias](
				idx0,
				idx1,
			),
			ddl.WithSchema[UserAlias, UserColumnAlias]("store"),
			ddl.WithPostStatements[UserAlias, UserColumnAlias](
				"ALTER TABLE {table} ENABLE ROW LEVEL SECURITY",
				"CREATE POLICY users_own_data ON {table} FOR ALL USING (id = current_setting('app.current_user_id')::bigint)",
				"CREATE POLICY users_insert ON {table} FOR INSERT WITH CHECK (true)",
			),
		),
		Id:               idCol,
		CreatedAt:        createdAtCol,
		UpdatedAt:        updatedAtCol,
		Email:            emailCol,
		FullName:         fullNameCol,
		IsActive:         isActiveCol,
		EmailConfirmedAt: emailConfirmedAtCol,
		Nickname:         nicknameCol,
		DeletedAt:        deletedAtCol,
	}
}()

Users is the global users table instance

View Source 
var UsersRef schema.RelationTableAlias[UserAlias] = Users.Table

UsersRef is a reference to the users table for relations

Functions

func IsAuditLogPrimaryKeyError added in v0.4.8 

func IsAuditLogPrimaryKeyError(err error) bool

IsAuditLogPrimaryKeyError checks if the error is a primary_key constraint violation on audit_logs

func IsCategoryPrimaryKeyError added in v0.2.0 

func IsCategoryPrimaryKeyError(err error) bool

IsCategoryPrimaryKeyError checks if the error is a primary_key constraint violation on categories

func IsCategorySlugUniqueError added in v0.2.0 

func IsCategorySlugUniqueError(err error) bool

IsCategorySlugUniqueError checks if the error is a unique constraint violation on categories

func IsCurrencyPrimaryKeyError added in v0.2.0 

func IsCurrencyPrimaryKeyError(err error) bool

IsCurrencyPrimaryKeyError checks if the error is a primary_key constraint violation on currency

func IsOrderCheckError added in v0.2.0 

func IsOrderCheckError(err error) bool

IsOrderCheckError checks if the error is a check constraint violation on orders

func IsOrderItemCheck1Error added in v0.2.0 

func IsOrderItemCheck1Error(err error) bool

IsOrderItemCheck1Error checks if the error is a check constraint violation on order_items

func IsOrderItemCheckError added in v0.2.0 

func IsOrderItemCheckError(err error) bool

IsOrderItemCheckError checks if the error is a check constraint violation on order_items

func IsOrderItemOrderIdProductIdUniqueError added in v0.2.0 

func IsOrderItemOrderIdProductIdUniqueError(err error) bool

IsOrderItemOrderIdProductIdUniqueError checks if the error is a unique constraint violation on order_items

func IsOrderItemPrimaryKeyError added in v0.2.0 

func IsOrderItemPrimaryKeyError(err error) bool

IsOrderItemPrimaryKeyError checks if the error is a primary_key constraint violation on order_items

func IsOrderPrimaryKeyError added in v0.2.0 

func IsOrderPrimaryKeyError(err error) bool

IsOrderPrimaryKeyError checks if the error is a primary_key constraint violation on orders

func IsProductCheckError added in v0.2.0 

func IsProductCheckError(err error) bool

IsProductCheckError checks if the error is a check constraint violation on products

func IsProductPrimaryKeyError added in v0.2.0 

func IsProductPrimaryKeyError(err error) bool

IsProductPrimaryKeyError checks if the error is a primary_key constraint violation on products

func IsProductSkuUniqueError added in v0.2.0 

func IsProductSkuUniqueError(err error) bool

IsProductSkuUniqueError checks if the error is a unique constraint violation on products

func IsProfilePrimaryKeyError added in v0.2.0 

func IsProfilePrimaryKeyError(err error) bool

IsProfilePrimaryKeyError checks if the error is a primary_key constraint violation on profiles

func IsProfileUserIdUniqueIdxError added in v0.2.0 

func IsProfileUserIdUniqueIdxError(err error) bool

IsProfileUserIdUniqueIdxError checks if the error is a unique constraint violation on profiles

func IsTagPrimaryKeyError added in v0.2.0 

func IsTagPrimaryKeyError(err error) bool

IsTagPrimaryKeyError checks if the error is a primary_key constraint violation on tags

func IsTagSlugUniqueError added in v0.2.0 

func IsTagSlugUniqueError(err error) bool

IsTagSlugUniqueError checks if the error is a unique constraint violation on tags

func IsUserEmailUniqueError added in v0.2.0 

func IsUserEmailUniqueError(err error) bool

IsUserEmailUniqueError checks if the error is a unique constraint violation on users

func IsUserEmailUniqueIdxError added in v0.2.0 

func IsUserEmailUniqueIdxError(err error) bool

IsUserEmailUniqueIdxError checks if the error is a unique constraint violation on users

func IsUserPreferencesPrimaryKeyError added in v0.4.7 

func IsUserPreferencesPrimaryKeyError(err error) bool

IsUserPreferencesPrimaryKeyError checks if the error is a primary_key constraint violation on user_preferences

func IsUserPrimaryKeyError added in v0.2.0 

func IsUserPrimaryKeyError(err error) bool

IsUserPrimaryKeyError checks if the error is a primary_key constraint violation on users

func IsUserSettingsPrimaryKeyError added in v0.4.7 

func IsUserSettingsPrimaryKeyError(err error) bool

IsUserSettingsPrimaryKeyError checks if the error is a primary_key constraint violation on user_settings

func OrderItemsWithAllRelations added in v0.2.0 

func OrderItemsWithAllRelations() exec.QueryOption[OrderItemColumnAlias, *OrderItemScanner]

OrderItemsWithAllRelations returns a QueryOption to load all relations

func OrderItemsWithOrder added in v0.2.0 

func OrderItemsWithOrder() exec.QueryOption[OrderItemColumnAlias, *OrderItemScanner]

OrderItemsWithOrder returns a QueryOption to load Order relation

func OrderItemsWithProduct added in v0.2.0 

func OrderItemsWithProduct() exec.QueryOption[OrderItemColumnAlias, *OrderItemScanner]

OrderItemsWithProduct returns a QueryOption to load Product relation

func OrdersWithAllRelations added in v0.2.0 

func OrdersWithAllRelations() exec.QueryOption[OrderColumnAlias, *OrderScanner]

OrdersWithAllRelations returns a QueryOption to load all relations

func OrdersWithItems added in v0.2.0 

func OrdersWithItems() exec.QueryOption[OrderColumnAlias, *OrderScanner]

OrdersWithItems returns a QueryOption to load Items relation

func OrdersWithMoney added in v0.2.0 

func OrdersWithMoney() exec.QueryOption[OrderColumnAlias, *OrderScanner]

OrdersWithMoney returns a QueryOption to load Money relation

func OrdersWithUser added in v0.2.0 

func OrdersWithUser() exec.QueryOption[OrderColumnAlias, *OrderScanner]

OrdersWithUser returns a QueryOption to load User relation

func ProfilesWithAllRelations added in v0.2.0 

func ProfilesWithAllRelations() exec.QueryOption[ProfileColumnAlias, *ProfileScanner]

ProfilesWithAllRelations returns a QueryOption to load all relations

func ProfilesWithUser added in v0.2.0 

func ProfilesWithUser() exec.QueryOption[ProfileColumnAlias, *ProfileScanner]

ProfilesWithUser returns a QueryOption to load User relation

func UsersWithAllRelations added in v0.2.0 

func UsersWithAllRelations() exec.QueryOption[UserColumnAlias, *UserScanner]

UsersWithAllRelations returns a QueryOption to load all relations

func UsersWithOrders added in v0.2.0 

func UsersWithOrders() exec.QueryOption[UserColumnAlias, *UserScanner]

UsersWithOrders returns a QueryOption to load Orders relation

func UsersWithProfile added in v0.2.0 

func UsersWithProfile() exec.QueryOption[UserColumnAlias, *UserScanner]

UsersWithProfile returns a QueryOption to load Profile relation

Types

type AppearanceSettings added in v0.4.7 

type AppearanceSettings struct {
	SelectedTheme *ThemeConfig `protobuf:"bytes,1,opt,name=selected_theme,json=selectedTheme,proto3" json:"selected_theme,omitempty"`
	FallbackTheme *ThemeConfig `protobuf:"bytes,2,opt,name=fallback_theme,json=fallbackTheme,proto3" json:"fallback_theme,omitempty"`
	// contains filtered or unexported fields
}

Тест: serialize = true на message поле ВНУТРИ embedded struct

func (*AppearanceSettings) Descriptor deprecated added in v0.4.7 

func (*AppearanceSettings) Descriptor() ([]byte, []int)

Deprecated: Use AppearanceSettings.ProtoReflect.Descriptor instead.

func (*AppearanceSettings) GetFallbackTheme added in v0.4.7 

func (x *AppearanceSettings) GetFallbackTheme() *ThemeConfig

func (*AppearanceSettings) GetSelectedTheme added in v0.4.7 

func (x *AppearanceSettings) GetSelectedTheme() *ThemeConfig

func (*AppearanceSettings) IntoPlain added in v0.4.7 

func (pb *AppearanceSettings) IntoPlain() *AppearanceSettingsScanner

IntoPlain converts protobuf message to plain struct

func (*AppearanceSettings) ProtoMessage added in v0.4.7 

func (*AppearanceSettings) ProtoMessage()

func (*AppearanceSettings) ProtoReflect added in v0.4.7 

func (x *AppearanceSettings) ProtoReflect() protoreflect.Message

func (*AppearanceSettings) Reset added in v0.4.7 

func (x *AppearanceSettings) Reset()

func (*AppearanceSettings) String added in v0.4.7 

func (x *AppearanceSettings) String() string

type AppearanceSettingsScanner added in v0.4.7 

type AppearanceSettingsScanner struct {
	SelectedTheme []byte `json:"selectedTheme"` // origin: serialized, empath: selected_theme
	FallbackTheme []byte `json:"fallbackTheme"` // origin: serialized, empath: fallback_theme
}

Тест: serialize = true на message поле ВНУТРИ embedded struct

func (*AppearanceSettingsScanner) IntoPb added in v0.4.7 

func (p *AppearanceSettingsScanner) IntoPb() *AppearanceSettings

IntoPb converts plain struct to protobuf message

type AuditCreateAction added in v0.4.19 

type AuditCreateAction struct {
	CreatedName string `protobuf:"bytes,1,opt,name=created_name,json=createdName,proto3" json:"created_name,omitempty"`
	// contains filtered or unexported fields
}

Oneof variant messages for testing embedded oneof in ratel tables

func (*AuditCreateAction) Descriptor deprecated added in v0.4.19 

func (*AuditCreateAction) Descriptor() ([]byte, []int)

Deprecated: Use AuditCreateAction.ProtoReflect.Descriptor instead.

func (*AuditCreateAction) GetCreatedName added in v0.4.19 

func (x *AuditCreateAction) GetCreatedName() string

func (*AuditCreateAction) IntoPlain added in v0.4.19 

func (pb *AuditCreateAction) IntoPlain() *AuditCreateActionScanner

IntoPlain converts protobuf message to plain struct

func (*AuditCreateAction) ProtoMessage added in v0.4.19 

func (*AuditCreateAction) ProtoMessage()

func (*AuditCreateAction) ProtoReflect added in v0.4.19 

func (x *AuditCreateAction) ProtoReflect() protoreflect.Message

func (*AuditCreateAction) Reset added in v0.4.19 

func (x *AuditCreateAction) Reset()

func (*AuditCreateAction) String added in v0.4.19 

func (x *AuditCreateAction) String() string

type AuditCreateActionScanner added in v0.4.19 

type AuditCreateActionScanner struct {
	CreatedName string `json:"createdName"`
}

Oneof variant messages for testing embedded oneof in ratel tables

func (*AuditCreateActionScanner) IntoPb added in v0.4.19 

func (p *AuditCreateActionScanner) IntoPb() *AuditCreateAction

IntoPb converts plain struct to protobuf message

type AuditDeleteAction added in v0.4.19 

type AuditDeleteAction struct {
	DeletedId int64  `protobuf:"varint,1,opt,name=deleted_id,json=deletedId,proto3" json:"deleted_id,omitempty"`
	Reason    string `protobuf:"bytes,2,opt,name=reason,proto3" json:"reason,omitempty"`
	// contains filtered or unexported fields
}

func (*AuditDeleteAction) Descriptor deprecated added in v0.4.19 

func (*AuditDeleteAction) Descriptor() ([]byte, []int)

Deprecated: Use AuditDeleteAction.ProtoReflect.Descriptor instead.

func (*AuditDeleteAction) GetDeletedId added in v0.4.19 

func (x *AuditDeleteAction) GetDeletedId() int64

func (*AuditDeleteAction) GetReason added in v0.4.19 

func (x *AuditDeleteAction) GetReason() string

func (*AuditDeleteAction) IntoPlain added in v0.4.19 

func (pb *AuditDeleteAction) IntoPlain() *AuditDeleteActionScanner

IntoPlain converts protobuf message to plain struct

func (*AuditDeleteAction) ProtoMessage added in v0.4.19 

func (*AuditDeleteAction) ProtoMessage()

func (*AuditDeleteAction) ProtoReflect added in v0.4.19 

func (x *AuditDeleteAction) ProtoReflect() protoreflect.Message

func (*AuditDeleteAction) Reset added in v0.4.19 

func (x *AuditDeleteAction) Reset()

func (*AuditDeleteAction) String added in v0.4.19 

func (x *AuditDeleteAction) String() string

type AuditDeleteActionScanner added in v0.4.19 

type AuditDeleteActionScanner struct {
	DeletedId int64  `json:"deletedId"`
	Reason    string `json:"reason"`
}

func (*AuditDeleteActionScanner) IntoPb added in v0.4.19 

func (p *AuditDeleteActionScanner) IntoPb() *AuditDeleteAction

IntoPb converts plain struct to protobuf message

type AuditLog added in v0.4.8 

type AuditLog struct {
	Id         int64  `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	Action     string `protobuf:"bytes,2,opt,name=action,proto3" json:"action,omitempty"`
	EntityType string `protobuf:"bytes,3,opt,name=entity_type,json=entityType,proto3" json:"entity_type,omitempty"`
	EntityId   int64  `protobuf:"varint,4,opt,name=entity_id,json=entityId,proto3" json:"entity_id,omitempty"`
	// repeated scalar → TEXT[] in PostgreSQL
	Tags       []string `protobuf:"bytes,5,rep,name=tags,proto3" json:"tags,omitempty"`
	RelatedIds []int64  `protobuf:"varint,6,rep,packed,name=related_ids,json=relatedIds,proto3" json:"related_ids,omitempty"`
	// enum field → TEXT in PostgreSQL, scanner should use string
	Severity AuditSeverity `protobuf:"varint,7,opt,name=severity,proto3,enum=store.AuditSeverity" json:"severity,omitempty"`
	// repeated enum field → TEXT[] in PostgreSQL, scanner should use []string
	AffectedLevels []AuditSeverity `` /* 136-byte string literal not displayed */
	// oneof embed — variants serialized into scanner
	//
	// Types that are valid to be assigned to Detail:
	//
	//	*AuditLog_CreateAction
	//	*AuditLog_DeleteAction
	Detail isAuditLog_Detail `protobuf_oneof:"detail"`
	// contains filtered or unexported fields
}

Тест: virtual_columns — колонки без proto field, только DDL

func (*AuditLog) Descriptor deprecated added in v0.4.8 

func (*AuditLog) Descriptor() ([]byte, []int)

Deprecated: Use AuditLog.ProtoReflect.Descriptor instead.

func (*AuditLog) GetAction added in v0.4.8 

func (x *AuditLog) GetAction() string

func (*AuditLog) GetAffectedLevels added in v0.4.18 

func (x *AuditLog) GetAffectedLevels() []AuditSeverity

func (*AuditLog) GetCreateAction added in v0.4.19 

func (x *AuditLog) GetCreateAction() *AuditCreateAction

func (*AuditLog) GetDeleteAction added in v0.4.19 

func (x *AuditLog) GetDeleteAction() *AuditDeleteAction

func (*AuditLog) GetDetail added in v0.4.19 

func (x *AuditLog) GetDetail() isAuditLog_Detail

func (*AuditLog) GetEntityId added in v0.4.8 

func (x *AuditLog) GetEntityId() int64

func (*AuditLog) GetEntityType added in v0.4.8 

func (x *AuditLog) GetEntityType() string

func (*AuditLog) GetId added in v0.4.8 

func (x *AuditLog) GetId() int64

func (*AuditLog) GetRelatedIds added in v0.4.10 

func (x *AuditLog) GetRelatedIds() []int64

func (*AuditLog) GetSeverity added in v0.4.17 

func (x *AuditLog) GetSeverity() AuditSeverity

func (*AuditLog) GetTags added in v0.4.10 

func (x *AuditLog) GetTags() []string

func (*AuditLog) IntoPlain added in v0.4.8 

func (pb *AuditLog) IntoPlain() *AuditLogScanner

IntoPlain converts protobuf message to plain struct

func (*AuditLog) ProtoMessage added in v0.4.8 

func (*AuditLog) ProtoMessage()

func (*AuditLog) ProtoReflect added in v0.4.8 

func (x *AuditLog) ProtoReflect() protoreflect.Message

func (*AuditLog) Reset added in v0.4.8 

func (x *AuditLog) Reset()

func (*AuditLog) String added in v0.4.8 

func (x *AuditLog) String() string

type AuditLogAlias added in v0.4.8 

type AuditLogAlias string

AuditLogAlias is the table alias type for the audit_logs table 

const AuditLogAliasName AuditLogAlias = "audit_logs"

func (AuditLogAlias) String added in v0.4.8 

func (a AuditLogAlias) String() string

type AuditLogColumnAlias added in v0.4.8 

type AuditLogColumnAlias string

AuditLogColumnAlias represents column names for the audit_logs table 

const (
	AuditLogColumnCreateActionCreateAction AuditLogColumnAlias = "create_action_create_action"
	AuditLogColumnDeleteActionDeleteAction AuditLogColumnAlias = "delete_action_delete_action"
	AuditLogColumnDetailCase               AuditLogColumnAlias = "detail_case"
	AuditLogColumnId                       AuditLogColumnAlias = "id"
	AuditLogColumnAction                   AuditLogColumnAlias = "action"
	AuditLogColumnEntityType               AuditLogColumnAlias = "entity_type"
	AuditLogColumnEntityId                 AuditLogColumnAlias = "entity_id"
	AuditLogColumnTags                     AuditLogColumnAlias = "tags"
	AuditLogColumnRelatedIds               AuditLogColumnAlias = "related_ids"
	AuditLogColumnSeverity                 AuditLogColumnAlias = "severity"
	AuditLogColumnAffectedLevels           AuditLogColumnAlias = "affected_levels"
	AuditLogColumnDbCreatedAt              AuditLogColumnAlias = "db_created_at"
	AuditLogColumnDbUpdatedAt              AuditLogColumnAlias = "db_updated_at"
)

func (AuditLogColumnAlias) String added in v0.4.8 

func (c AuditLogColumnAlias) String() string

type AuditLogScanner added in v0.4.8 

type AuditLogScanner struct {
	Id                       int64    `json:"id"`
	Action                   string   `json:"action"`
	EntityType               string   `json:"entityType"`
	EntityId                 int64    `json:"entityId"`
	Tags                     []string `json:"tags"`
	RelatedIds               []int64  `json:"relatedIds"`
	Severity                 string   `json:"severity"`
	AffectedLevels           []string `json:"affectedLevels"`
	CreateActionCreateAction []byte   `json:"createActionCreateAction"` // origin: serialized, empath: create_action.create_action
	DeleteActionDeleteAction []byte   `json:"deleteActionDeleteAction"` // origin: serialized, empath: delete_action.delete_action
	DbCreatedAt              string   `json:"dbCreatedAt"`              // origin: virtual, empath: virtual
	DbUpdatedAt              string   `json:"dbUpdatedAt"`              // origin: virtual, empath: virtual
	// DetailCase indicates which variant of detail oneof is set
	DetailCase string `json:"detail_case,omitempty"`
}

Тест: virtual_columns — колонки без proto field, только DDL

func (*AuditLogScanner) AllSetters added in v0.4.9 

func (s *AuditLogScanner) AllSetters() []set.ValueSetter[AuditLogColumnAlias]

func (*AuditLogScanner) GetSetter added in v0.4.8 

func (s *AuditLogScanner) GetSetter(f AuditLogColumnAlias) func() set.ValueSetter[AuditLogColumnAlias]

func (*AuditLogScanner) GetTarget added in v0.4.8 

func (s *AuditLogScanner) GetTarget(col string) func() any

func (*AuditLogScanner) GetValue added in v0.4.8 

func (s *AuditLogScanner) GetValue(f AuditLogColumnAlias) func() any

func (*AuditLogScanner) IntoPb added in v0.4.8 

func (p *AuditLogScanner) IntoPb() *AuditLog

IntoPb converts plain struct to protobuf message

func (*AuditLogScanner) Relations added in v0.4.8 

func (s *AuditLogScanner) Relations() []exec.RelationLoader[*AuditLogScanner]

Relations returns the relation loaders for the audit_logs table

func (*AuditLogScanner) WithDbCreatedAt added in v0.4.9 

func (p *AuditLogScanner) WithDbCreatedAt(v string) *AuditLogScanner

WithDbCreatedAt sets the virtual field DbCreatedAt

func (*AuditLogScanner) WithDbUpdatedAt added in v0.4.9 

func (p *AuditLogScanner) WithDbUpdatedAt(v string) *AuditLogScanner

WithDbUpdatedAt sets the virtual field DbUpdatedAt

type AuditLog_CreateAction added in v0.4.19 

type AuditLog_CreateAction struct {
	CreateAction *AuditCreateAction `protobuf:"bytes,10,opt,name=create_action,json=createAction,proto3,oneof"`
}

type AuditLog_DeleteAction added in v0.4.19 

type AuditLog_DeleteAction struct {
	DeleteAction *AuditDeleteAction `protobuf:"bytes,11,opt,name=delete_action,json=deleteAction,proto3,oneof"`
}

type AuditLogsTable added in v0.4.8 

type AuditLogsTable struct {
	*schema.Table[AuditLogAlias, AuditLogColumnAlias, *AuditLogScanner]
	CreateActionCreateAction schema.NullJSONBColumnI[AuditLogColumnAlias]
	DeleteActionDeleteAction schema.NullJSONBColumnI[AuditLogColumnAlias]
	DetailCase               schema.TextColumnI[AuditLogColumnAlias]
	Id                       schema.BigSerialColumnI[AuditLogColumnAlias]
	Action                   schema.TextColumnI[AuditLogColumnAlias]
	EntityType               schema.TextColumnI[AuditLogColumnAlias]
	EntityId                 schema.BigIntColumnI[AuditLogColumnAlias]
	Tags                     schema.TextArrayColumnI[AuditLogColumnAlias]
	RelatedIds               schema.BigIntArrayColumnI[AuditLogColumnAlias]
	Severity                 schema.TextColumnI[AuditLogColumnAlias]
	AffectedLevels           schema.TextArrayColumnI[AuditLogColumnAlias]
	DbCreatedAt              schema.TimestamptzColumnI[AuditLogColumnAlias]
	DbUpdatedAt              schema.TimestamptzColumnI[AuditLogColumnAlias]
}

AuditLogsTable represents the audit_logs table with its columns

type AuditSeverity added in v0.4.17 

type AuditSeverity int32

Enum for testing enum-as-string scanning 

const (
	AuditSeverity_AUDIT_SEVERITY_UNSPECIFIED AuditSeverity = 0
	AuditSeverity_AUDIT_SEVERITY_LOW         AuditSeverity = 1
	AuditSeverity_AUDIT_SEVERITY_MEDIUM      AuditSeverity = 2
	AuditSeverity_AUDIT_SEVERITY_HIGH        AuditSeverity = 3
	AuditSeverity_AUDIT_SEVERITY_CRITICAL    AuditSeverity = 4
)

func (AuditSeverity) Descriptor added in v0.4.17 

func (AuditSeverity) Descriptor() protoreflect.EnumDescriptor

func (AuditSeverity) Enum added in v0.4.17 

func (x AuditSeverity) Enum() *AuditSeverity

func (AuditSeverity) EnumDescriptor deprecated added in v0.4.17 

func (AuditSeverity) EnumDescriptor() ([]byte, []int)

Deprecated: Use AuditSeverity.Descriptor instead.

func (AuditSeverity) Number added in v0.4.17 

func (x AuditSeverity) Number() protoreflect.EnumNumber

func (AuditSeverity) String added in v0.4.17 

func (x AuditSeverity) String() string

func (AuditSeverity) Type added in v0.4.17 

func (AuditSeverity) Type() protoreflect.EnumType

type BaseEntity 

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
}

============================================================================ BaseEntity - базовая сущность с ID и timestamps (nested embed) ============================================================================

func (*BaseEntity) Descriptor deprecated 

func (*BaseEntity) Descriptor() ([]byte, []int)

Deprecated: Use BaseEntity.ProtoReflect.Descriptor instead.

func (*BaseEntity) GetId 

func (x *BaseEntity) GetId() *EntityID

func (*BaseEntity) GetTimestamps 

func (x *BaseEntity) GetTimestamps() *Timestamps

func (*BaseEntity) IntoPlain 

func (pb *BaseEntity) IntoPlain() *BaseEntityScanner

IntoPlain converts protobuf message to plain struct

func (*BaseEntity) ProtoMessage 

func (*BaseEntity) ProtoMessage()

func (*BaseEntity) ProtoReflect 

func (x *BaseEntity) ProtoReflect() protoreflect.Message

func (*BaseEntity) Reset 

func (x *BaseEntity) Reset()

func (*BaseEntity) String 

func (x *BaseEntity) String() string

type BaseEntityScanner 

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

============================================================================ 

BaseEntity - базовая сущность с ID и timestamps (nested embed)
============================================================================

func (*BaseEntityScanner) IntoPb 

func (p *BaseEntityScanner) IntoPb() *BaseEntity

IntoPb converts plain struct to protobuf message

type Category 

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"` // nullable self-referencing FK
	// contains filtered or unexported fields
}

============================================================================ Category - категория товаров (с BaseEntity) ============================================================================

func (*Category) Descriptor deprecated 

func (*Category) Descriptor() ([]byte, []int)

Deprecated: Use Category.ProtoReflect.Descriptor instead.

func (*Category) GetBase 

func (x *Category) GetBase() *BaseEntity

func (*Category) GetName 

func (x *Category) GetName() string

func (*Category) GetParentId 

func (x *Category) GetParentId() *wrapperspb.Int64Value

func (*Category) GetSlug 

func (x *Category) GetSlug() string

func (*Category) IntoPlain 

func (pb *Category) IntoPlain() *CategoryScanner

IntoPlain converts protobuf message to plain struct

func (*Category) ProtoMessage 

func (*Category) ProtoMessage()

func (*Category) ProtoReflect 

func (x *Category) ProtoReflect() protoreflect.Message

func (*Category) Reset 

func (x *Category) Reset()

func (*Category) String 

func (x *Category) String() string

type CategoryAlias 

type CategoryAlias string

CategoryAlias is the table alias type for the categories table 

const CategoryAliasName CategoryAlias = "categories"

func (CategoryAlias) String 

func (a CategoryAlias) String() string

type CategoryColumnAlias 

type CategoryColumnAlias string

CategoryColumnAlias represents column names for the categories table 

const (
	CategoryColumnId        CategoryColumnAlias = "id"
	CategoryColumnCreatedAt CategoryColumnAlias = "created_at"
	CategoryColumnUpdatedAt CategoryColumnAlias = "updated_at"
	CategoryColumnName      CategoryColumnAlias = "name"
	CategoryColumnSlug      CategoryColumnAlias = "slug"
	CategoryColumnParentId  CategoryColumnAlias = "parent_id"
)

func (CategoryColumnAlias) String 

func (c CategoryColumnAlias) String() string

type CategoryScanner 

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"`
}

============================================================================ 

Category - категория товаров (с BaseEntity)
============================================================================

func (*CategoryScanner) AllSetters added in v0.4.9 

func (s *CategoryScanner) AllSetters() []set.ValueSetter[CategoryColumnAlias]

func (*CategoryScanner) GetSetter 

func (s *CategoryScanner) GetSetter(f CategoryColumnAlias) func() set.ValueSetter[CategoryColumnAlias]

func (*CategoryScanner) GetTarget 

func (s *CategoryScanner) GetTarget(col string) func() any

func (*CategoryScanner) GetValue 

func (s *CategoryScanner) GetValue(f CategoryColumnAlias) func() any

func (*CategoryScanner) IntoPb 

func (p *CategoryScanner) IntoPb() *Category

IntoPb converts plain struct to protobuf message

func (*CategoryScanner) Relations 

func (s *CategoryScanner) Relations() []exec.RelationLoader[*CategoryScanner]

Relations returns the relation loaders for the categories table

type CategorysTable 

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]
}

CategorysTable represents the categories table with its columns

type Currency 

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
}

============================================================================ Currency - справочник валют (не использует BaseEntity) ============================================================================

func (*Currency) Descriptor deprecated 

func (*Currency) Descriptor() ([]byte, []int)

Deprecated: Use Currency.ProtoReflect.Descriptor instead.

func (*Currency) GetCode 

func (x *Currency) GetCode() string

func (*Currency) GetName 

func (x *Currency) GetName() string

func (*Currency) IntoPlain 

func (pb *Currency) IntoPlain() *CurrencyScanner

IntoPlain converts protobuf message to plain struct

func (*Currency) ProtoMessage 

func (*Currency) ProtoMessage()

func (*Currency) ProtoReflect 

func (x *Currency) ProtoReflect() protoreflect.Message

func (*Currency) Reset 

func (x *Currency) Reset()

func (*Currency) String 

func (x *Currency) String() string

type CurrencyAlias 

type CurrencyAlias string

CurrencyAlias is the table alias type for the currency table 

const CurrencyAliasName CurrencyAlias = "currency"

func (CurrencyAlias) String 

func (a CurrencyAlias) String() string

type CurrencyColumnAlias 

type CurrencyColumnAlias string

CurrencyColumnAlias represents column names for the currency table 

const (
	CurrencyColumnCode CurrencyColumnAlias = "code"
	CurrencyColumnName CurrencyColumnAlias = "name"
)

func (CurrencyColumnAlias) String 

func (c CurrencyColumnAlias) String() string

type CurrencyScanner 

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

============================================================================ 

Currency - справочник валют (не использует BaseEntity)
============================================================================

func (*CurrencyScanner) AllSetters added in v0.4.9 

func (s *CurrencyScanner) AllSetters() []set.ValueSetter[CurrencyColumnAlias]

func (*CurrencyScanner) GetSetter 

func (s *CurrencyScanner) GetSetter(f CurrencyColumnAlias) func() set.ValueSetter[CurrencyColumnAlias]

func (*CurrencyScanner) GetTarget 

func (s *CurrencyScanner) GetTarget(col string) func() any

func (*CurrencyScanner) GetValue 

func (s *CurrencyScanner) GetValue(f CurrencyColumnAlias) func() any

func (*CurrencyScanner) IntoPb 

func (p *CurrencyScanner) IntoPb() *Currency

IntoPb converts plain struct to protobuf message

func (*CurrencyScanner) Relations 

func (s *CurrencyScanner) Relations() []exec.RelationLoader[*CurrencyScanner]

Relations returns the relation loaders for the currency table

type CurrencysTable 

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

CurrencysTable represents the currency table with its columns

type EntityID 

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

EntityID - базовый type alias для ID сущностей

func (*EntityID) Descriptor deprecated 

func (*EntityID) Descriptor() ([]byte, []int)

Deprecated: Use EntityID.ProtoReflect.Descriptor instead.

func (*EntityID) GetValue 

func (x *EntityID) GetValue() int64

func (*EntityID) ProtoMessage 

func (*EntityID) ProtoMessage()

func (*EntityID) ProtoReflect 

func (x *EntityID) ProtoReflect() protoreflect.Message

func (*EntityID) Reset 

func (x *EntityID) Reset()

func (*EntityID) String 

func (x *EntityID) String() string

type Order 

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
}

============================================================================ Order - заказ (с BaseEntity) ============================================================================

func (*Order) Descriptor deprecated 

func (*Order) Descriptor() ([]byte, []int)

Deprecated: Use Order.ProtoReflect.Descriptor instead.

func (*Order) GetBase 

func (x *Order) GetBase() *BaseEntity

func (*Order) GetCurrency 

func (x *Order) GetCurrency() string

func (*Order) GetItems 

func (x *Order) GetItems() []*OrderItem

func (*Order) GetMoney added in v0.2.0 

func (x *Order) GetMoney() *Currency

func (*Order) GetStatus 

func (x *Order) GetStatus() string

func (*Order) GetUser added in v0.2.0 

func (x *Order) GetUser() *User

func (*Order) GetUserId 

func (x *Order) GetUserId() *EntityID

func (*Order) IntoPlain 

func (pb *Order) IntoPlain() *OrderScanner

IntoPlain converts protobuf message to plain struct

func (*Order) ProtoMessage 

func (*Order) ProtoMessage()

func (*Order) ProtoReflect 

func (x *Order) ProtoReflect() protoreflect.Message

func (*Order) Reset 

func (x *Order) Reset()

func (*Order) String 

func (x *Order) String() string

type OrderAlias 

type OrderAlias string

OrderAlias is the table alias type for the orders table 

const OrderAliasName OrderAlias = "orders"

func (OrderAlias) String 

func (a OrderAlias) String() string

type OrderColumnAlias 

type OrderColumnAlias string

OrderColumnAlias represents column names for the orders table 

const (
	OrderColumnId        OrderColumnAlias = "id"
	OrderColumnCreatedAt OrderColumnAlias = "created_at"
	OrderColumnUpdatedAt OrderColumnAlias = "updated_at"
	OrderColumnUserId    OrderColumnAlias = "user_id"
	OrderColumnStatus    OrderColumnAlias = "status"
	OrderColumnCurrency  OrderColumnAlias = "currency"
)

func (OrderColumnAlias) String 

func (c OrderColumnAlias) String() string

type OrderItem 

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
}

============================================================================ OrderItem - позиция заказа (без BaseEntity - композитный PK) ============================================================================

func (*OrderItem) Descriptor deprecated 

func (*OrderItem) Descriptor() ([]byte, []int)

Deprecated: Use OrderItem.ProtoReflect.Descriptor instead.

func (*OrderItem) GetLineNo 

func (x *OrderItem) GetLineNo() int32

func (*OrderItem) GetOrder added in v0.2.0 

func (x *OrderItem) GetOrder() *Order

func (*OrderItem) GetOrderId 

func (x *OrderItem) GetOrderId() *EntityID

func (*OrderItem) GetProduct added in v0.2.0 

func (x *OrderItem) GetProduct() *Product

func (*OrderItem) GetProductId 

func (x *OrderItem) GetProductId() *EntityID

func (*OrderItem) GetQty 

func (x *OrderItem) GetQty() int32

func (*OrderItem) GetUnitPrice 

func (x *OrderItem) GetUnitPrice() float64

func (*OrderItem) IntoPlain 

func (pb *OrderItem) IntoPlain() *OrderItemScanner

IntoPlain converts protobuf message to plain struct

func (*OrderItem) ProtoMessage 

func (*OrderItem) ProtoMessage()

func (*OrderItem) ProtoReflect 

func (x *OrderItem) ProtoReflect() protoreflect.Message

func (*OrderItem) Reset 

func (x *OrderItem) Reset()

func (*OrderItem) String 

func (x *OrderItem) String() string

type OrderItemAlias 

type OrderItemAlias string

OrderItemAlias is the table alias type for the order_items table 

const OrderItemAliasName OrderItemAlias = "order_items"

func (OrderItemAlias) String 

func (a OrderItemAlias) String() string

type OrderItemColumnAlias 

type OrderItemColumnAlias string

OrderItemColumnAlias represents column names for the order_items table 

const (
	OrderItemColumnOrderId   OrderItemColumnAlias = "order_id"
	OrderItemColumnLineNo    OrderItemColumnAlias = "line_no"
	OrderItemColumnProductId OrderItemColumnAlias = "product_id"
	OrderItemColumnQty       OrderItemColumnAlias = "qty"
	OrderItemColumnUnitPrice OrderItemColumnAlias = "unit_price"
)

func (OrderItemColumnAlias) String 

func (c OrderItemColumnAlias) String() string

type OrderItemScanner 

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"`
}

============================================================================ 

OrderItem - позиция заказа (без BaseEntity - композитный PK)
============================================================================

func (*OrderItemScanner) AllSetters added in v0.4.9 

func (s *OrderItemScanner) AllSetters() []set.ValueSetter[OrderItemColumnAlias]

func (*OrderItemScanner) GetSetter 

func (s *OrderItemScanner) GetSetter(f OrderItemColumnAlias) func() set.ValueSetter[OrderItemColumnAlias]

func (*OrderItemScanner) GetTarget 

func (s *OrderItemScanner) GetTarget(col string) func() any

func (*OrderItemScanner) GetValue 

func (s *OrderItemScanner) GetValue(f OrderItemColumnAlias) func() any

func (*OrderItemScanner) IntoPb 

func (p *OrderItemScanner) IntoPb() *OrderItem

IntoPb converts plain struct to protobuf message

func (*OrderItemScanner) Relations 

func (s *OrderItemScanner) Relations() []exec.RelationLoader[*OrderItemScanner]

Relations returns the relation loaders for the order_items table

type OrderItemsTable 

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]
}

OrderItemsTable represents the order_items table with its columns

type OrderScanner 

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"`
}

============================================================================ 

Order - заказ (с BaseEntity)
============================================================================

func (*OrderScanner) AllSetters added in v0.4.9 

func (s *OrderScanner) AllSetters() []set.ValueSetter[OrderColumnAlias]

func (*OrderScanner) GetSetter 

func (s *OrderScanner) GetSetter(f OrderColumnAlias) func() set.ValueSetter[OrderColumnAlias]

func (*OrderScanner) GetTarget 

func (s *OrderScanner) GetTarget(col string) func() any

func (*OrderScanner) GetValue 

func (s *OrderScanner) GetValue(f OrderColumnAlias) func() any

func (*OrderScanner) IntoPb 

func (p *OrderScanner) IntoPb() *Order

IntoPb converts plain struct to protobuf message

func (*OrderScanner) Relations 

func (s *OrderScanner) Relations() []exec.RelationLoader[*OrderScanner]

Relations returns the relation loaders for the orders table

type OrdersTable 

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]
}

OrdersTable represents the orders table with its columns

type Product 

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
}

============================================================================ Product - товар (с BaseEntity) ============================================================================

func (*Product) Descriptor deprecated 

func (*Product) Descriptor() ([]byte, []int)

Deprecated: Use Product.ProtoReflect.Descriptor instead.

func (*Product) GetBase 

func (x *Product) GetBase() *BaseEntity

func (*Product) GetCategories 

func (x *Product) GetCategories() []*Category

func (*Product) GetCurrency 

func (x *Product) GetCurrency() string

func (*Product) GetIsDeleted 

func (x *Product) GetIsDeleted() bool

func (*Product) GetName 

func (x *Product) GetName() string

func (*Product) GetPrice 

func (x *Product) GetPrice() float64

func (*Product) GetSku 

func (x *Product) GetSku() string

func (*Product) GetStockQty 

func (x *Product) GetStockQty() int32

func (*Product) GetTags 

func (x *Product) GetTags() []*Tag

func (*Product) IntoPlain 

func (pb *Product) IntoPlain() *ProductScanner

IntoPlain converts protobuf message to plain struct

func (*Product) ProtoMessage 

func (*Product) ProtoMessage()

func (*Product) ProtoReflect 

func (x *Product) ProtoReflect() protoreflect.Message

func (*Product) Reset 

func (x *Product) Reset()

func (*Product) String 

func (x *Product) String() string

type ProductAlias 

type ProductAlias string

ProductAlias is the table alias type for the products table 

const ProductAliasName ProductAlias = "products"

func (ProductAlias) String 

func (a ProductAlias) String() string

type ProductColumnAlias 

type ProductColumnAlias string

ProductColumnAlias represents column names for the products table 

const (
	ProductColumnId        ProductColumnAlias = "id"
	ProductColumnCreatedAt ProductColumnAlias = "created_at"
	ProductColumnUpdatedAt ProductColumnAlias = "updated_at"
	ProductColumnSku       ProductColumnAlias = "sku"
	ProductColumnName      ProductColumnAlias = "name"
	ProductColumnPrice     ProductColumnAlias = "price"
	ProductColumnCurrency  ProductColumnAlias = "currency"
	ProductColumnStockQty  ProductColumnAlias = "stock_qty"
	ProductColumnIsDeleted ProductColumnAlias = "is_deleted"
)

func (ProductColumnAlias) String 

func (c ProductColumnAlias) String() string

type ProductScanner 

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"`
}

============================================================================ 

Product - товар (с BaseEntity)
============================================================================

func (*ProductScanner) AllSetters added in v0.4.9 

func (s *ProductScanner) AllSetters() []set.ValueSetter[ProductColumnAlias]

func (*ProductScanner) GetSetter 

func (s *ProductScanner) GetSetter(f ProductColumnAlias) func() set.ValueSetter[ProductColumnAlias]

func (*ProductScanner) GetTarget 

func (s *ProductScanner) GetTarget(col string) func() any

func (*ProductScanner) GetValue 

func (s *ProductScanner) GetValue(f ProductColumnAlias) func() any

func (*ProductScanner) IntoPb 

func (p *ProductScanner) IntoPb() *Product

IntoPb converts plain struct to protobuf message

func (*ProductScanner) Relations 

func (s *ProductScanner) Relations() []exec.RelationLoader[*ProductScanner]

Relations returns the relation loaders for the products table

type ProductsTable 

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]
}

ProductsTable represents the products table with its columns

type Profile added in v0.2.0 

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
}

============================================================================ Profile - профиль пользователя (один к одному с User) ============================================================================

func (*Profile) Descriptor deprecated added in v0.2.0 

func (*Profile) Descriptor() ([]byte, []int)

Deprecated: Use Profile.ProtoReflect.Descriptor instead.

func (*Profile) GetAvatarUrl added in v0.2.0 

func (x *Profile) GetAvatarUrl() string

func (*Profile) GetBase added in v0.2.0 

func (x *Profile) GetBase() *BaseEntity

func (*Profile) GetBio added in v0.2.0 

func (x *Profile) GetBio() string

func (*Profile) GetUser added in v0.2.0 

func (x *Profile) GetUser() *User

func (*Profile) GetUserId added in v0.2.0 

func (x *Profile) GetUserId() *EntityID

func (*Profile) IntoPlain added in v0.2.0 

func (pb *Profile) IntoPlain() *ProfileScanner

IntoPlain converts protobuf message to plain struct

func (*Profile) ProtoMessage added in v0.2.0 

func (*Profile) ProtoMessage()

func (*Profile) ProtoReflect added in v0.2.0 

func (x *Profile) ProtoReflect() protoreflect.Message

func (*Profile) Reset added in v0.2.0 

func (x *Profile) Reset()

func (*Profile) String added in v0.2.0 

func (x *Profile) String() string

type ProfileAlias added in v0.2.0 

type ProfileAlias string

ProfileAlias is the table alias type for the profiles table 

const ProfileAliasName ProfileAlias = "profiles"

func (ProfileAlias) String added in v0.2.0 

func (a ProfileAlias) String() string

type ProfileColumnAlias added in v0.2.0 

type ProfileColumnAlias string

ProfileColumnAlias represents column names for the profiles table 

const (
	ProfileColumnId        ProfileColumnAlias = "id"
	ProfileColumnCreatedAt ProfileColumnAlias = "created_at"
	ProfileColumnUpdatedAt ProfileColumnAlias = "updated_at"
	ProfileColumnUserId    ProfileColumnAlias = "user_id"
	ProfileColumnBio       ProfileColumnAlias = "bio"
	ProfileColumnAvatarUrl ProfileColumnAlias = "avatar_url"
)

func (ProfileColumnAlias) String added in v0.2.0 

func (c ProfileColumnAlias) String() string

type ProfileScanner added in v0.2.0 

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"`
}

============================================================================ 

Profile - профиль пользователя (один к одному с User)
============================================================================

func (*ProfileScanner) AllSetters added in v0.4.9 

func (s *ProfileScanner) AllSetters() []set.ValueSetter[ProfileColumnAlias]

func (*ProfileScanner) GetSetter added in v0.2.0 

func (s *ProfileScanner) GetSetter(f ProfileColumnAlias) func() set.ValueSetter[ProfileColumnAlias]

func (*ProfileScanner) GetTarget added in v0.2.0 

func (s *ProfileScanner) GetTarget(col string) func() any

func (*ProfileScanner) GetValue added in v0.2.0 

func (s *ProfileScanner) GetValue(f ProfileColumnAlias) func() any

func (*ProfileScanner) IntoPb added in v0.2.0 

func (p *ProfileScanner) IntoPb() *Profile

IntoPb converts plain struct to protobuf message

func (*ProfileScanner) Relations added in v0.2.0 

func (s *ProfileScanner) Relations() []exec.RelationLoader[*ProfileScanner]

Relations returns the relation loaders for the profiles table

type ProfilesTable added in v0.2.0 

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]
}

ProfilesTable represents the profiles table with its columns

type Tag 

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
}

============================================================================ Tag - тег для товаров (с BaseEntity) ============================================================================

func (*Tag) Descriptor deprecated 

func (*Tag) Descriptor() ([]byte, []int)

Deprecated: Use Tag.ProtoReflect.Descriptor instead.

func (*Tag) GetBase 

func (x *Tag) GetBase() *BaseEntity

func (*Tag) GetName 

func (x *Tag) GetName() string

func (*Tag) GetSlug 

func (x *Tag) GetSlug() string

func (*Tag) IntoPlain 

func (pb *Tag) IntoPlain() *TagScanner

IntoPlain converts protobuf message to plain struct

func (*Tag) ProtoMessage 

func (*Tag) ProtoMessage()

func (*Tag) ProtoReflect 

func (x *Tag) ProtoReflect() protoreflect.Message

func (*Tag) Reset 

func (x *Tag) Reset()

func (*Tag) String 

func (x *Tag) String() string

type TagAlias 

type TagAlias string

TagAlias is the table alias type for the tags table 

const TagAliasName TagAlias = "tags"

func (TagAlias) String 

func (a TagAlias) String() string

type TagColumnAlias 

type TagColumnAlias string

TagColumnAlias represents column names for the tags table 

const (
	TagColumnId        TagColumnAlias = "id"
	TagColumnCreatedAt TagColumnAlias = "created_at"
	TagColumnUpdatedAt TagColumnAlias = "updated_at"
	TagColumnName      TagColumnAlias = "name"
	TagColumnSlug      TagColumnAlias = "slug"
)

func (TagColumnAlias) String 

func (c TagColumnAlias) String() string

type TagScanner 

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"`
}

============================================================================ 

Tag - тег для товаров (с BaseEntity)
============================================================================

func (*TagScanner) AllSetters added in v0.4.9 

func (s *TagScanner) AllSetters() []set.ValueSetter[TagColumnAlias]

func (*TagScanner) GetSetter 

func (s *TagScanner) GetSetter(f TagColumnAlias) func() set.ValueSetter[TagColumnAlias]

func (*TagScanner) GetTarget 

func (s *TagScanner) GetTarget(col string) func() any

func (*TagScanner) GetValue 

func (s *TagScanner) GetValue(f TagColumnAlias) func() any

func (*TagScanner) IntoPb 

func (p *TagScanner) IntoPb() *Tag

IntoPb converts plain struct to protobuf message

func (*TagScanner) Relations 

func (s *TagScanner) Relations() []exec.RelationLoader[*TagScanner]

Relations returns the relation loaders for the tags table

type TagsTable 

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]
}

TagsTable represents the tags table with its columns

type ThemeConfig added in v0.4.7 

type ThemeConfig struct {
	PrimaryColor string `protobuf:"bytes,1,opt,name=primary_color,json=primaryColor,proto3" json:"primary_color,omitempty"`
	FontFamily   string `protobuf:"bytes,2,opt,name=font_family,json=fontFamily,proto3" json:"font_family,omitempty"`
	// contains filtered or unexported fields
}

============================================================================ Settings - тест serialize = true на message полях ============================================================================

func (*ThemeConfig) Descriptor deprecated added in v0.4.7 

func (*ThemeConfig) Descriptor() ([]byte, []int)

Deprecated: Use ThemeConfig.ProtoReflect.Descriptor instead.

func (*ThemeConfig) GetFontFamily added in v0.4.7 

func (x *ThemeConfig) GetFontFamily() string

func (*ThemeConfig) GetPrimaryColor added in v0.4.7 

func (x *ThemeConfig) GetPrimaryColor() string

func (*ThemeConfig) ProtoMessage added in v0.4.7 

func (*ThemeConfig) ProtoMessage()

func (*ThemeConfig) ProtoReflect added in v0.4.7 

func (x *ThemeConfig) ProtoReflect() protoreflect.Message

func (*ThemeConfig) Reset added in v0.4.7 

func (x *ThemeConfig) Reset()

func (*ThemeConfig) String added in v0.4.7 

func (x *ThemeConfig) String() string

type Timestamps 

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
}

============================================================================ Timestamps - embedded message для created_at/updated_at ============================================================================

func (*Timestamps) Descriptor deprecated 

func (*Timestamps) Descriptor() ([]byte, []int)

Deprecated: Use Timestamps.ProtoReflect.Descriptor instead.

func (*Timestamps) GetCreatedAt 

func (x *Timestamps) GetCreatedAt() *timestamppb.Timestamp

func (*Timestamps) GetUpdatedAt 

func (x *Timestamps) GetUpdatedAt() *timestamppb.Timestamp

func (*Timestamps) IntoPlain 

func (pb *Timestamps) IntoPlain() *TimestampsScanner

IntoPlain converts protobuf message to plain struct

func (*Timestamps) ProtoMessage 

func (*Timestamps) ProtoMessage()

func (*Timestamps) ProtoReflect 

func (x *Timestamps) ProtoReflect() protoreflect.Message

func (*Timestamps) Reset 

func (x *Timestamps) Reset()

func (*Timestamps) String 

func (x *Timestamps) String() string

type TimestampsScanner 

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

============================================================================ 

Timestamps - embedded message для created_at/updated_at
============================================================================

func (*TimestampsScanner) IntoPb 

func (p *TimestampsScanner) IntoPb() *Timestamps

IntoPb converts plain struct to protobuf message

type User 

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"`
	// Nullable via proto3 optional on Timestamp
	EmailConfirmedAt *timestamppb.Timestamp `protobuf:"bytes,5,opt,name=email_confirmed_at,json=emailConfirmedAt,proto3,oneof" json:"email_confirmed_at,omitempty"`
	// Nullable via proto3 optional on scalar
	Nickname *string `protobuf:"bytes,6,opt,name=nickname,proto3,oneof" json:"nickname,omitempty"`
	// Nullable via proto3 optional on Timestamp
	DeletedAt *timestamppb.Timestamp `protobuf:"bytes,7,opt,name=deleted_at,json=deletedAt,proto3,oneof" json:"deleted_at,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
}

============================================================================ User - пользователь системы (с BaseEntity) ============================================================================

func (*User) Descriptor deprecated 

func (*User) Descriptor() ([]byte, []int)

Deprecated: Use User.ProtoReflect.Descriptor instead.

func (*User) GetBase 

func (x *User) GetBase() *BaseEntity

func (*User) GetDeletedAt added in v0.3.0 

func (x *User) GetDeletedAt() *timestamppb.Timestamp

func (*User) GetEmail 

func (x *User) GetEmail() string

func (*User) GetEmailConfirmedAt added in v0.3.0 

func (x *User) GetEmailConfirmedAt() *timestamppb.Timestamp

func (*User) GetFullName 

func (x *User) GetFullName() string

func (*User) GetIsActive 

func (x *User) GetIsActive() bool

func (*User) GetNickname added in v0.3.0 

func (x *User) GetNickname() string

func (*User) GetOrders 

func (x *User) GetOrders() []*Order

func (*User) GetProfile added in v0.2.0 

func (x *User) GetProfile() *Profile

func (*User) IntoPlain 

func (pb *User) IntoPlain() *UserScanner

IntoPlain converts protobuf message to plain struct

func (*User) ProtoMessage 

func (*User) ProtoMessage()

func (*User) ProtoReflect 

func (x *User) ProtoReflect() protoreflect.Message

func (*User) Reset 

func (x *User) Reset()

func (*User) String 

func (x *User) String() string

type UserAlias 

type UserAlias string

UserAlias is the table alias type for the users table 

const UserAliasName UserAlias = "users"

func (UserAlias) String 

func (a UserAlias) String() string

type UserColumnAlias 

type UserColumnAlias string

UserColumnAlias represents column names for the users table 

const (
	UserColumnId               UserColumnAlias = "id"
	UserColumnCreatedAt        UserColumnAlias = "created_at"
	UserColumnUpdatedAt        UserColumnAlias = "updated_at"
	UserColumnEmail            UserColumnAlias = "email"
	UserColumnFullName         UserColumnAlias = "full_name"
	UserColumnIsActive         UserColumnAlias = "is_active"
	UserColumnEmailConfirmedAt UserColumnAlias = "email_confirmed_at"
	UserColumnNickname         UserColumnAlias = "nickname"
	UserColumnDeletedAt        UserColumnAlias = "deleted_at"
)

func (UserColumnAlias) String 

func (c UserColumnAlias) String() string

type UserPreferences added in v0.4.7 

type UserPreferences struct {
	Id     int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	UserId int64 `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// embed с serialize полями внутри
	Appearance *AppearanceSettings `protobuf:"bytes,3,opt,name=appearance,proto3" json:"appearance,omitempty"`
	// contains filtered or unexported fields
}

func (*UserPreferences) Descriptor deprecated added in v0.4.7 

func (*UserPreferences) Descriptor() ([]byte, []int)

Deprecated: Use UserPreferences.ProtoReflect.Descriptor instead.

func (*UserPreferences) GetAppearance added in v0.4.7 

func (x *UserPreferences) GetAppearance() *AppearanceSettings

func (*UserPreferences) GetId added in v0.4.7 

func (x *UserPreferences) GetId() int64

func (*UserPreferences) GetUserId added in v0.4.7 

func (x *UserPreferences) GetUserId() int64

func (*UserPreferences) IntoPlain added in v0.4.7 

func (pb *UserPreferences) IntoPlain() *UserPreferencesScanner

IntoPlain converts protobuf message to plain struct

func (*UserPreferences) ProtoMessage added in v0.4.7 

func (*UserPreferences) ProtoMessage()

func (*UserPreferences) ProtoReflect added in v0.4.7 

func (x *UserPreferences) ProtoReflect() protoreflect.Message

func (*UserPreferences) Reset added in v0.4.7 

func (x *UserPreferences) Reset()

func (*UserPreferences) String added in v0.4.7 

func (x *UserPreferences) String() string

type UserPreferencesAlias added in v0.4.7 

type UserPreferencesAlias string

UserPreferencesAlias is the table alias type for the user_preferences table 

const UserPreferencesAliasName UserPreferencesAlias = "user_preferences"

func (UserPreferencesAlias) String added in v0.4.7 

func (a UserPreferencesAlias) String() string

type UserPreferencesColumnAlias added in v0.4.7 

type UserPreferencesColumnAlias string

UserPreferencesColumnAlias represents column names for the user_preferences table 

const (
	UserPreferencesColumnId            UserPreferencesColumnAlias = "id"
	UserPreferencesColumnUserId        UserPreferencesColumnAlias = "user_id"
	UserPreferencesColumnSelectedTheme UserPreferencesColumnAlias = "selected_theme"
	UserPreferencesColumnFallbackTheme UserPreferencesColumnAlias = "fallback_theme"
)

func (UserPreferencesColumnAlias) String added in v0.4.7 

func (c UserPreferencesColumnAlias) String() string

type UserPreferencesScanner added in v0.4.7 

type UserPreferencesScanner struct {
	Id            int64  `json:"id"`
	UserId        int64  `json:"userId"`
	SelectedTheme []byte `json:"selectedTheme"` // origin: serialized, empath: selected_theme
	FallbackTheme []byte `json:"fallbackTheme"` // origin: serialized, empath: fallback_theme
}

func (*UserPreferencesScanner) AllSetters added in v0.4.9 

func (s *UserPreferencesScanner) AllSetters() []set.ValueSetter[UserPreferencesColumnAlias]

func (*UserPreferencesScanner) GetSetter added in v0.4.7 

func (s *UserPreferencesScanner) GetSetter(f UserPreferencesColumnAlias) func() set.ValueSetter[UserPreferencesColumnAlias]

func (*UserPreferencesScanner) GetTarget added in v0.4.7 

func (s *UserPreferencesScanner) GetTarget(col string) func() any

func (*UserPreferencesScanner) GetValue added in v0.4.7 

func (s *UserPreferencesScanner) GetValue(f UserPreferencesColumnAlias) func() any

func (*UserPreferencesScanner) IntoPb added in v0.4.7 

func (p *UserPreferencesScanner) IntoPb() *UserPreferences

IntoPb converts plain struct to protobuf message

func (*UserPreferencesScanner) Relations added in v0.4.7 

func (s *UserPreferencesScanner) Relations() []exec.RelationLoader[*UserPreferencesScanner]

Relations returns the relation loaders for the user_preferences table

type UserPreferencessTable added in v0.4.7 

type UserPreferencessTable struct {
	*schema.Table[UserPreferencesAlias, UserPreferencesColumnAlias, *UserPreferencesScanner]
	Id            schema.BigSerialColumnI[UserPreferencesColumnAlias]
	UserId        schema.BigIntColumnI[UserPreferencesColumnAlias]
	SelectedTheme schema.TextColumnI[UserPreferencesColumnAlias]
	FallbackTheme schema.TextColumnI[UserPreferencesColumnAlias]
}

UserPreferencessTable represents the user_preferences table with its columns

type UserScanner 

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"`
	EmailConfirmedAt *time.Time      `json:"emailConfirmedAt,omitempty"`
	Nickname         *string         `json:"nickname,omitempty"`
	DeletedAt        *time.Time      `json:"deletedAt,omitempty"`
	Orders           []OrderScanner  `json:"orders"`
	Profile          *ProfileScanner `json:"profile"`
}

============================================================================ 

User - пользователь системы (с BaseEntity)
============================================================================

func (*UserScanner) AllSetters added in v0.4.9 

func (s *UserScanner) AllSetters() []set.ValueSetter[UserColumnAlias]

func (*UserScanner) GetSetter 

func (s *UserScanner) GetSetter(f UserColumnAlias) func() set.ValueSetter[UserColumnAlias]

func (*UserScanner) GetTarget 

func (s *UserScanner) GetTarget(col string) func() any

func (*UserScanner) GetValue 

func (s *UserScanner) GetValue(f UserColumnAlias) func() any

func (*UserScanner) IntoPb 

func (p *UserScanner) IntoPb() *User

IntoPb converts plain struct to protobuf message

func (*UserScanner) Relations 

func (s *UserScanner) Relations() []exec.RelationLoader[*UserScanner]

Relations returns the relation loaders for the users table

type UserSettings added in v0.4.7 

type UserSettings struct {
	Id     int64 `protobuf:"varint,1,opt,name=id,proto3" json:"id,omitempty"`
	UserId int64 `protobuf:"varint,2,opt,name=user_id,json=userId,proto3" json:"user_id,omitempty"`
	// serialize = true: message -> []byte via proto.Marshal/Unmarshal
	Theme *ThemeConfig `protobuf:"bytes,3,opt,name=theme,proto3" json:"theme,omitempty"`
	// contains filtered or unexported fields
}

Тест: serialize = true на message поле (прямое — не embedded)

func (*UserSettings) Descriptor deprecated added in v0.4.7 

func (*UserSettings) Descriptor() ([]byte, []int)

Deprecated: Use UserSettings.ProtoReflect.Descriptor instead.

func (*UserSettings) GetId added in v0.4.7 

func (x *UserSettings) GetId() int64

func (*UserSettings) GetTheme added in v0.4.7 

func (x *UserSettings) GetTheme() *ThemeConfig

func (*UserSettings) GetUserId added in v0.4.7 

func (x *UserSettings) GetUserId() int64

func (*UserSettings) IntoPlain added in v0.4.7 

func (pb *UserSettings) IntoPlain() *UserSettingsScanner

IntoPlain converts protobuf message to plain struct

func (*UserSettings) ProtoMessage added in v0.4.7 

func (*UserSettings) ProtoMessage()

func (*UserSettings) ProtoReflect added in v0.4.7 

func (x *UserSettings) ProtoReflect() protoreflect.Message

func (*UserSettings) Reset added in v0.4.7 

func (x *UserSettings) Reset()

func (*UserSettings) String added in v0.4.7 

func (x *UserSettings) String() string

type UserSettingsAlias added in v0.4.7 

type UserSettingsAlias string

UserSettingsAlias is the table alias type for the user_settings table 

const UserSettingsAliasName UserSettingsAlias = "user_settings"

func (UserSettingsAlias) String added in v0.4.7 

func (a UserSettingsAlias) String() string

type UserSettingsColumnAlias added in v0.4.7 

type UserSettingsColumnAlias string

UserSettingsColumnAlias represents column names for the user_settings table 

const (
	UserSettingsColumnId     UserSettingsColumnAlias = "id"
	UserSettingsColumnUserId UserSettingsColumnAlias = "user_id"
	UserSettingsColumnTheme  UserSettingsColumnAlias = "theme"
)

func (UserSettingsColumnAlias) String added in v0.4.7 

func (c UserSettingsColumnAlias) String() string

type UserSettingsScanner added in v0.4.7 

type UserSettingsScanner struct {
	Id     int64  `json:"id"`
	UserId int64  `json:"userId"`
	Theme  []byte `json:"theme"` // origin: serialized, empath: theme
}

Тест: serialize = true на message поле (прямое — не embedded)

func (*UserSettingsScanner) AllSetters added in v0.4.9 

func (s *UserSettingsScanner) AllSetters() []set.ValueSetter[UserSettingsColumnAlias]

func (*UserSettingsScanner) GetSetter added in v0.4.7 

func (s *UserSettingsScanner) GetSetter(f UserSettingsColumnAlias) func() set.ValueSetter[UserSettingsColumnAlias]

func (*UserSettingsScanner) GetTarget added in v0.4.7 

func (s *UserSettingsScanner) GetTarget(col string) func() any

func (*UserSettingsScanner) GetValue added in v0.4.7 

func (s *UserSettingsScanner) GetValue(f UserSettingsColumnAlias) func() any

func (*UserSettingsScanner) IntoPb added in v0.4.7 

func (p *UserSettingsScanner) IntoPb() *UserSettings

IntoPb converts plain struct to protobuf message

func (*UserSettingsScanner) Relations added in v0.4.7 

func (s *UserSettingsScanner) Relations() []exec.RelationLoader[*UserSettingsScanner]

Relations returns the relation loaders for the user_settings table

type UserSettingssTable added in v0.4.7 

type UserSettingssTable struct {
	*schema.Table[UserSettingsAlias, UserSettingsColumnAlias, *UserSettingsScanner]
	Id     schema.BigSerialColumnI[UserSettingsColumnAlias]
	UserId schema.BigIntColumnI[UserSettingsColumnAlias]
	Theme  schema.TextColumnI[UserSettingsColumnAlias]
}

UserSettingssTable represents the user_settings table with its columns

type UsersTable 

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]
	EmailConfirmedAt schema.NullTimestamptzColumnI[UserColumnAlias]
	Nickname         schema.NullTextColumnI[UserColumnAlias]
	DeletedAt        schema.NullTimestamptzColumnI[UserColumnAlias]
}

UsersTable represents the users table with its columns

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.