mixin

type AgentMixin ¶ added in v0.3.0

type AgentMixin struct {
	mixin.Schema
}

AgentMixin provides fields for the Agent entity (AI agents). Agent extends Principal with AI agent-specific data. Use this mixin for AI agents that act on behalf of humans or organizations.

func (AgentMixin) Fields() []ent.Field

func (AgentMixin) Indexes() []ent.Index

type ApplicationMixin ¶ added in v0.3.0

type ApplicationMixin struct {
	mixin.Schema
}

ApplicationMixin provides fields for the Application entity (OAuth clients). Application extends Principal with OAuth client-specific data. Use this mixin for OAuth2 client applications.

Apps must define:

• principal_id field (FK to Principal)
• Edge from Principal to Application

func (ApplicationMixin) Fields() []ent.Field

func (ApplicationMixin) Indexes() []ent.Index

type BaseMixin ¶

type BaseMixin struct {
	mixin.Schema
}

BaseMixin combines UUID and Timestamp mixins for convenience. This is the most commonly used mixin for CoreForge-compatible entities.

func (BaseMixin) Fields() []ent.Field

type CreatorOrgMixin ¶ added in v0.3.0

type CreatorOrgMixin struct {
	mixin.Schema
}

CreatorOrgMixin provides fields for creator/publisher organizations. Use this mixin for organizations that create and sell products on the marketplace. This is separate from OrganizationBase which is for consumer organizations.

func (CreatorOrgMixin) Fields() []ent.Field

type HumanMixin ¶ added in v0.3.0

type HumanMixin struct {
	mixin.Schema
}

HumanMixin provides fields for the Human entity. Human extends Principal with human-specific data (email, name, avatar, etc.). Use this mixin to create Human entities in your app.

Apps must define:

• principal_id field (FK to Principal)
• Edge from Principal to Human

Example usage:

type Human struct {
    ent.Schema
}

func (Human) Mixin() []ent.Mixin {
    return []ent.Mixin{
        cfmixin.HumanMixin{},
    }
}

func (Human) Fields() []ent.Field {
    return []ent.Field{
        // App-specific fields (e.g., bio, headline, username)
    }
}

func (Human) Edges() []ent.Edge {
    return []ent.Edge{
        edge.From("principal", Principal.Type).
            Ref("human").
            Field("principal_id").
            Unique().
            Required().
            Immutable(),
    }
}

func (HumanMixin) Fields() []ent.Field

func (HumanMixin) Indexes() []ent.Index

type LicenseMixin ¶ added in v0.3.0

type LicenseMixin struct {
	mixin.Schema
}

LicenseMixin provides the core fields for marketplace licenses. Apps can use this mixin to create their own License schema while adding app-specific fields and edges.

func (LicenseMixin) Fields() []ent.Field

type ListingMixin ¶ added in v0.3.0

type ListingMixin struct {
	mixin.Schema
}

ListingMixin provides the core fields for marketplace listings. Apps can use this mixin to create their own Listing schema while adding app-specific fields and edges.

Example usage:

type Listing struct {
    ent.Schema
}

func (Listing) Mixin() []ent.Mixin {
    return []ent.Mixin{
        mixin.ListingMixin{},
    }
}

func (Listing) Fields() []ent.Field {
    return []ent.Field{
        // App-specific fields
        field.UUID("course_id", uuid.UUID{}).Optional(),
    }
}

func (ListingMixin) Fields() []ent.Field

type MembershipBase ¶

type MembershipBase struct {
	mixin.Schema
}

MembershipBase provides the core membership fields for composition. Apps can use this mixin to get CoreForge-compatible membership fields while customizing role values for their domain.

func (MembershipBase) Fields() []ent.Field

type MembershipRole ¶ added in v0.3.0

type MembershipRole string

MembershipRole defines the standard roles for organization membership.

const (
	// MembershipRoleOwner has full control including billing and deletion.
	MembershipRoleOwner MembershipRole = "owner"
	// MembershipRoleAdmin can manage members and most settings.
	MembershipRoleAdmin MembershipRole = "admin"
	// MembershipRoleEditor can create and modify content.
	MembershipRoleEditor MembershipRole = "editor"
	// MembershipRoleViewer can only view content.
	MembershipRoleViewer MembershipRole = "viewer"
)

type OAuthAccountMixin ¶ added in v0.3.0

type OAuthAccountMixin struct {
	mixin.Schema
}

OAuthAccountMixin provides fields for the OAuthAccount entity. OAuthAccount stores OAuth provider connections for principals. Use this mixin to create OAuthAccount entities in your app.

Apps must define:

• principal_id field (FK to Principal)
• Edge from Principal to OAuthAccount

Example usage:

type OAuthAccount struct {
    ent.Schema
}

func (OAuthAccount) Mixin() []ent.Mixin {
    return []ent.Mixin{
        cfmixin.OAuthAccountMixin{},
    }
}

func (OAuthAccount) Edges() []ent.Edge {
    return []ent.Edge{
        edge.From("principal", Principal.Type).
            Ref("oauth_accounts").
            Field("principal_id").
            Unique().
            Required(),
    }
}

func (OAuthAccountMixin) Fields() []ent.Field

func (OAuthAccountMixin) Indexes() []ent.Index

type OrganizationBase ¶

type OrganizationBase struct {
	mixin.Schema
}

OrganizationBase provides the core organization fields for composition. Apps can use this mixin to get CoreForge-compatible organization fields while adding their own custom fields or renaming to match their domain (e.g., Team, Tenant, Workspace).

func (OrganizationBase) Fields() []ent.Field

type PrincipalMembershipMixin ¶ added in v0.3.0

type PrincipalMembershipMixin struct {
	mixin.Schema
}

PrincipalMembershipMixin provides fields for the PrincipalMembership entity. PrincipalMembership links Principals to Organizations with roles. Use this mixin to create PrincipalMembership entities in your app.

Apps must define:

• Edges from Principal and Organization to PrincipalMembership

Example usage:

type PrincipalMembership struct {
    ent.Schema
}

func (PrincipalMembership) Mixin() []ent.Mixin {
    return []ent.Mixin{
        cfmixin.PrincipalMembershipMixin{},
    }
}

func (PrincipalMembership) Edges() []ent.Edge {
    return []ent.Edge{
        edge.From("principal", Principal.Type).
            Ref("memberships").
            Field("principal_id").
            Unique().
            Required(),
        edge.From("organization", Organization.Type).
            Ref("principal_memberships").
            Field("organization_id").
            Unique().
            Required(),
    }
}

func (PrincipalMembershipMixin) Fields() []ent.Field

func (PrincipalMembershipMixin) Indexes() []ent.Index

type PrincipalMixin ¶ added in v0.3.0

type PrincipalMixin struct {
	mixin.Schema
}

PrincipalMixin provides fields for the Principal entity. Principal is the unified identity type representing any actor in the system. Use this mixin to create Principal entities in your app.

Apps must define edges to:

• Human (one-to-one, optional) - for human-specific data
• OAuthAccount (one-to-many) - for OAuth connections
• RefreshToken (one-to-many) - for token management
• PrincipalMembership (one-to-many) - for organization membership

Example usage:

type Principal struct {
    ent.Schema
}

func (Principal) Mixin() []ent.Mixin {
    return []ent.Mixin{
        cfmixin.PrincipalMixin{},
    }
}

func (Principal) Fields() []ent.Field {
    return []ent.Field{
        // App-specific fields if needed
    }
}

func (Principal) Edges() []ent.Edge {
    return []ent.Edge{
        edge.To("human", Human.Type).Unique(),
        edge.To("oauth_accounts", OAuthAccount.Type),
        edge.To("refresh_tokens", RefreshToken.Type),
        edge.To("memberships", PrincipalMembership.Type),
    }
}

func (PrincipalMixin) Fields() []ent.Field

func (PrincipalMixin) Indexes() []ent.Index

type PrincipalType ¶ added in v0.3.0

type PrincipalType string

PrincipalType defines the types of principals in the identity system.

const (
	// PrincipalTypeHuman represents a human user.
	PrincipalTypeHuman PrincipalType = "human"
	// PrincipalTypeApplication represents an OAuth application/client.
	PrincipalTypeApplication PrincipalType = "application"
	// PrincipalTypeAgent represents an AI agent or automated actor.
	PrincipalTypeAgent PrincipalType = "agent"
	// PrincipalTypeService represents a service account for system processes.
	PrincipalTypeService PrincipalType = "service"
)

type RefreshTokenMixin ¶ added in v0.3.0

type RefreshTokenMixin struct {
	mixin.Schema
}

RefreshTokenMixin provides fields for the RefreshToken entity. RefreshToken stores refresh tokens for token-based authentication. Use this mixin to create RefreshToken entities in your app.

Apps must define:

• principal_id field (FK to Principal)
• Edge from Principal to RefreshToken

Example usage:

type RefreshToken struct {
    ent.Schema
}

func (RefreshToken) Mixin() []ent.Mixin {
    return []ent.Mixin{
        cfmixin.RefreshTokenMixin{},
    }
}

func (RefreshToken) Edges() []ent.Edge {
    return []ent.Edge{
        edge.From("principal", Principal.Type).
            Ref("refresh_tokens").
            Field("principal_id").
            Unique().
            Required(),
    }
}

func (RefreshTokenMixin) Fields() []ent.Field

func (RefreshTokenMixin) Indexes() []ent.Index

type SeatAssignmentMixin ¶ added in v0.3.0

type SeatAssignmentMixin struct {
	mixin.Schema
}

SeatAssignmentMixin provides the core fields for license seat assignments. Apps can use this mixin to track which principals are assigned to license seats.

func (SeatAssignmentMixin) Fields() []ent.Field

type ServicePrincipalMixin ¶ added in v0.3.0

type ServicePrincipalMixin struct {
	mixin.Schema
}

ServicePrincipalMixin provides fields for the ServicePrincipal entity. ServicePrincipal extends Principal for system service accounts. Use this mixin for background jobs, cron tasks, and system processes.

func (ServicePrincipalMixin) Fields() []ent.Field

func (ServicePrincipalMixin) Indexes() []ent.Index

type SubscriptionMixin ¶ added in v0.3.0

type SubscriptionMixin struct {
	mixin.Schema
}

SubscriptionMixin provides the core fields for platform subscriptions. Apps can use this mixin to create their own Subscription schema for tracking organization-level platform access.

func (SubscriptionMixin) Fields() []ent.Field

type TimestampMixin ¶

type TimestampMixin struct {
	mixin.Schema
}

TimestampMixin provides created_at and updated_at timestamp fields. Use this for automatic timestamp tracking in your schema.

func (TimestampMixin) Fields() []ent.Field

type UUIDMixin ¶

type UUIDMixin struct {
	mixin.Schema
}

UUIDMixin provides a UUID primary key field. Use this when you want UUID-based primary keys in your schema.

func (UUIDMixin) Fields() []ent.Field

type UserBase ¶

type UserBase struct {
	mixin.Schema
}

UserBase provides the core user fields for composition into app schemas. Apps can use this mixin to get CoreForge-compatible user fields while adding their own custom fields.

Example usage:

type User struct {
    ent.Schema
}

func (User) Mixin() []ent.Mixin {
    return []ent.Mixin{
        mixin.UserBase{},
    }
}

func (User) Fields() []ent.Field {
    return []ent.Field{
        // App-specific fields
        field.String("username").Unique(),
    }
}

func (UserBase) Fields() []ent.Field