studio black

package dev.studioblack.service;

import dev.studioblack.model.Project;
import dev.studioblack.repository.ProjectRepository;
import dev.studioblack.event.ProjectCreatedEvent;
import java.util.List;

public class ProjectService {

    private final ProjectRepository repository;
    private final EventBus eventBus;
    private final CacheStore cache;

    public ProjectService(ProjectRepository repository,
                          EventBus eventBus,
                          CacheStore cache) {
        this.repository = repository;
        this.eventBus = eventBus;
        this.cache = cache;
    }

    public List<Project> findActive() {
        return cache.get("projects:active", () ->
            repository.findByStatus(Project.Status.ACTIVE)
        );
    }

    @Transactional
    public Project create(CreateProjectRequest request) {
        if (repository.existsBySlug(request.slug())) {
            throw new ConflictException("Slug already exists");
        }

        Project project = Project.builder()
            .title(request.title())
            .slug(request.slug())
            .stack(request.stack())
            .status(Project.Status.DRAFT)
            .build();

        project = repository.save(project);
        cache.evict("projects:active");
        eventBus.publish(new ProjectCreatedEvent(project));
        return project;
    }
}

local World = {}
World.__index = World

function World:new()
    local w = setmetatable({}, self)
    w.entities = {}
    w.pools = {}
    w.nextId = 1
    return w
end

function World:spawn(components)
    local id = self.nextId
    self.nextId = id + 1
    self.entities[id] = true

    for name, data in pairs(components) do
        if not self.pools[name] then
            self.pools[name] = {}
        end
        self.pools[name][id] = data
    end
    return id
end

function World:query(...)
    local names = {...}
    local result = {}

    for id in pairs(self.entities) do
        local match = true
        for _, name in ipairs(names) do
            if not self.pools[name]
               or not self.pools[name][id] then
                match = false
                break
            end
        end
        if match then
            result[#result + 1] = id
        end
    end
    return result
end

function World:get(id, component)
    return self.pools[component]
       and self.pools[component][id]
end

function World:destroy(id)
    for _, pool in pairs(self.pools) do
        pool[id] = nil
    end
    self.entities[id] = nil
end

return World

CREATE TABLE clients (
    id         INTEGER PRIMARY KEY,
    name       TEXT NOT NULL,
    email      TEXT UNIQUE NOT NULL,
    tier       TEXT CHECK(tier IN ('free','pro','enterprise'))
               DEFAULT 'free',
    created_at TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
);

CREATE TABLE projects (
    id          INTEGER PRIMARY KEY,
    client_id   INTEGER NOT NULL REFERENCES clients(id),
    title       TEXT NOT NULL,
    slug        TEXT UNIQUE NOT NULL,
    status      TEXT CHECK(status IN ('draft','active','archived'))
                DEFAULT 'draft',
    stack       TEXT NOT NULL,
    deployed_at TEXT,
    created_at  TEXT DEFAULT (strftime('%Y-%m-%dT%H:%M:%SZ','now'))
);

CREATE INDEX idx_projects_status ON projects(status);
CREATE INDEX idx_projects_client ON projects(client_id);


SELECT
    c.name                          AS client,
    c.tier,
    COUNT(p.id)                     AS total_projects,
    SUM(CASE WHEN p.status = 'active'
             THEN 1 ELSE 0 END)    AS live,
    MAX(p.deployed_at)              AS last_deploy
FROM clients c
LEFT JOIN projects p ON p.client_id = c.id
GROUP BY c.id
HAVING total_projects > 0
ORDER BY live DESC, last_deploy DESC;