CREATE TABLE "profile" (
  "id" CHAR(26) PRIMARY KEY,
  "slug" TEXT NOT NULL UNIQUE,
  "kind" TEXT NOT NULL,                    -- 'individual', 'organization', 'product'
  "custom_domain" TEXT,                    -- e.g., 'eser.dev'
  "profile_picture_uri" TEXT,
  "pronouns" TEXT,                         -- e.g., 'he/him', 'she/her', 'they/them'
  "properties" JSONB,                      -- Custom metadata (extensible)
  "created_at" TIMESTAMP WITH TIME ZONE DEFAULT NOW(),
  "updated_at" TIMESTAMP WITH TIME ZONE,
  "deleted_at" TIMESTAMP WITH TIME ZONE,   -- Soft delete
  "approved_at" TIMESTAMP WITH TIME ZONE   -- Moderation approval
);

import { backend } from "@/modules/backend/backend.ts";

// 1. Initiate OAuth flow
const { authUrl } = await backend.initiateProfileLinkOAuth(
  locale,
  profileSlug,
  "github"
);
window.location.href = authUrl;

// 2. After OAuth callback, finalize connection
const { link } = await backend.finalizeGitHubConnection(
  locale,
  profileSlug,
  code // from OAuth callback
);

// 3. Link is now created with is_managed=true, is_verified=true
// GitHub repos will auto-sync as profile resources

const permissions = await backend.getProfilePermissions(locale, profileSlug);

if (permissions.canEdit) {
  // Show edit button
}

if (permissions.canManageMembers) {
  // Show team management
}

if (permissions.canDelete) {
  // Show delete option
}

package profiles

type Permissions struct {
    CanEdit          bool
    CanManageMembers bool
    CanDelete        bool
    CanPublishStories bool
}

func GetPermissions(
    ctx context.Context,
    repo Repository,
    profileID string,
    userID *string,
) (*Permissions, error) {
    if userID == nil {
        return &Permissions{}, nil // Anonymous user
    }

    // Check if user owns individual profile
    user, _ := repo.GetUserByID(ctx, *userID)
    if user.IndividualProfileID == profileID {
        return &Permissions{
            CanEdit:          true,
            CanDelete:        true,
            CanPublishStories: true,
        }, nil
    }

    // Check membership for organization/product profiles
    membership, _ := repo.GetMembership(ctx, profileID, user.IndividualProfileID)
    if membership != nil {
        return &Permissions{
            CanEdit:           membership.Kind == "owner" || membership.Kind == "admin",
            CanManageMembers:  membership.Kind == "owner" || membership.Kind == "admin",
            CanDelete:         membership.Kind == "owner",
            CanPublishStories: true,
        }, nil
    }

    return &Permissions{}, nil
}

package profiles

import (
    "context"
    "aya.is/apps/services/pkg/ajan/results"
)

var ErrProfileNotFound = results.ErrNotFound("Profile not found")

func Get(
    ctx context.Context,
    repo Repository,
    localeCode string,
    slug string,
) (*Profile, error) {
    profile, err := repo.GetBySlug(ctx, localeCode, slug)
    if err != nil {
        return nil, err
    }

    // Business rule: Don't show deleted profiles
    if profile.DeletedAt != nil {
        return nil, ErrProfileNotFound
    }

    // Business rule: Only show approved profiles to public
    // (Note: In actual code, this would check user permissions)
    if profile.ApprovedAt == nil {
        return nil, ErrProfileNotFound
    }

    return profile, nil
}

package profiles

import (
    "context"
    "time"
    "github.com/segmentio/ksuid"
)

type CreateProfileInput struct {
    Slug        string
    Kind        string
    Title       string
    Description string
    LocaleCode  string
}

func Create(
    ctx context.Context,
    repo Repository,
    input CreateProfileInput,
) (*Profile, error) {
    // Business rule: Validate slug format
    if !isValidSlug(input.Slug) {
        return nil, ErrInvalidSlug
    }

    // Business rule: Check slug availability
    exists, _ := repo.SlugExists(ctx, input.Slug)
    if exists {
        return nil, ErrSlugTaken
    }

    // Business rule: Validate kind
    if !isValidKind(input.Kind) {
        return nil, ErrInvalidKind
    }

    profile := &Profile{
        ID:        ksuid.New().String(),
        Slug:      input.Slug,
        Kind:      input.Kind,
        CreatedAt: time.Now(),
    }

    translation := &ProfileTranslation{
        ProfileID:  profile.ID,
        LocaleCode: input.LocaleCode,
        Title:      input.Title,
        Description: input.Description,
    }

    if err := repo.Create(ctx, profile, translation); err != nil {
        return nil, err
    }

    return profile, nil
}

func isValidSlug(slug string) bool {
    // Business rule: Slugs must be lowercase alphanumeric + hyphens
    matched, _ := regexp.MatchString(`^[a-z0-9][a-z0-9-]{1,38}[a-z0-9]$`, slug)
    return matched
}

func isValidKind(kind string) bool {
    return kind == "individual" || kind == "organization" || kind == "product"
}

import { createFileRoute } from "@tanstack/react-router";
import { useSuspenseQuery } from "@tanstack/react-query";
import { profileQueryOptions, profileStoriesQueryOptions } from "@/modules/backend/queries";
import { QueryError } from "@/components/query-error";

export const Route = createFileRoute("/$locale/$slug/")({
  // Prefetch profile for SSR
  loader: async ({ params, context }) => {
    const { locale, slug } = params;

    // Ensure profile data (needed for head())
    const profile = await context.queryClient.ensureQueryData(
      profileQueryOptions(locale, slug)
    );

    // Prefetch stories (optional, component-only)
    await context.queryClient.prefetchQuery(
      profileStoriesQueryOptions(locale, slug)
    );

    return { locale, slug, profile };
  },

  // Meta tags from loader data
  head: ({ loaderData }) => ({
    title: loaderData.profile.title,
    meta: [
      { name: "description", content: loaderData.profile.description },
      { property: "og:title", content: loaderData.profile.title },
      { property: "og:image", content: loaderData.profile.profilePictureUri },
    ],
  }),

  errorComponent: QueryError,
});

function ProfilePage() {
  const { locale, slug } = Route.useParams();

  // Read from hydrated cache
  const { data: profile } = useSuspenseQuery(profileQueryOptions(locale, slug));
  const { data: stories } = useSuspenseQuery(profileStoriesQueryOptions(locale, slug));

  return (
    <div>
      <h1>{profile.title}</h1>
      <p>{profile.description}</p>

      <h2>Stories</h2>
      {stories.map((story) => (
        <StoryCard key={story.id} story={story} />
      ))}
    </div>
  );
}

export default ProfilePage;

import { useState } from "react";
import { useMutation, useQueryClient } from "@tanstack/react-query";
import { backend } from "@/modules/backend/backend.ts";
import { profileQueryOptions } from "@/modules/backend/queries";

type Props = {
  locale: string;
  profile: Profile;
};

export function EditProfileForm(props: Props) {
  const [title, setTitle] = useState(props.profile.title);
  const [description, setDescription] = useState(props.profile.description);
  const queryClient = useQueryClient();

  const updateMutation = useMutation({
    mutationFn: () =>
      backend.updateProfile(props.locale, props.profile.slug, {
        title,
        description,
      }),
    onSuccess: (updatedProfile) => {
      // Optimistically update cache
      queryClient.setQueryData(
        profileQueryOptions(props.locale, props.profile.slug).queryKey,
        updatedProfile
      );
    },
  });

  return (
    <form
      onSubmit={(e) => {
        e.preventDefault();
        updateMutation.mutate();
      }}
    >
      <input
        type="text"
        value={title}
        onChange={(e) => setTitle(e.target.value)}
        placeholder="Profile title"
      />
      <textarea
        value={description}
        onChange={(e) => setDescription(e.target.value)}
        placeholder="Description"
      />
      <button type="submit" disabled={updateMutation.isPending}>
        {updateMutation.isPending ? "Saving..." : "Save"}
      </button>
    </form>
  );
}