@happyvertical/smrt-app-shell 0.0.0-stage → 0.60.17

package/dist/lib/server/owner.js

@@ -0,0 +1,92 @@
+// Who may do what, in one place. The shell has exactly one person: the owner.
+// Every builder operation, approval decision and route requires the owner's
+// session; the engine's `approved` flag is reachable only from
+// `Approval.decide` (see approvals.ts).
+//
+// Owner = an ACTIVE membership holding the built-in system `owner` role in the
+// principal's tenant, looked up in shell.db on every check (no claim in a
+// token, header or request body is trusted).
+import { getCurrentTenant, withTenant, } from '@happyvertical/smrt-tenancy';
+import { DEFAULT_ROLE_SLUGS, MembershipCollection, MembershipStatus, RoleCollection, } from '@happyvertical/smrt-users';
+import { getShellDb } from "./host.js";
+export class PolicyError extends Error {
+    status;
+    constructor(status, message) {
+        super(message);
+        this.name = 'PolicyError';
+        this.status = status;
+    }
+}
+async function ownerFromDatabase(principal) {
+    const db = await getShellDb();
+    const roles = await RoleCollection.create({ db });
+    const ownerRole = await roles.findSystemRoleBySlug(DEFAULT_ROLE_SLUGS.OWNER);
+    if (!ownerRole?.id)
+        return false;
+    const memberships = await MembershipCollection.create({ db });
+    const membership = await memberships.findByUserAndTenant(principal.id, principal.tenantId);
+    return (!!membership &&
+        membership.status === MembershipStatus.ACTIVE &&
+        membership.roleId === ownerRole.id);
+}
+let override = null;
+/** Tests only: replace the database lookup. Pass null to restore it. */
+export function setOwnerCheck(check) {
+    override = check;
+}
+export async function isOwner(principal) {
+    if (!principal?.id || !principal.tenantId)
+        return false;
+    try {
+        return await (override ?? ownerFromDatabase)(principal);
+    }
+    catch {
+        return false; // fail closed
+    }
+}
+/** The principal, or a 401 (nobody) / 403 (somebody who is not the owner). */
+export async function requireOwner(principal) {
+    if (!principal?.id || !principal.tenantId)
+        throw new PolicyError(401, 'sign in first');
+    if (!(await isOwner(principal)))
+        throw new PolicyError(403, 'only the owner can do this');
+    return principal;
+}
+/** The principal of a SvelteKit request, from the verified session only. */
+export function principalFromLocals(locals) {
+    const id = locals.user?.id;
+    if (typeof id !== 'string' || !id)
+        return null;
+    if (typeof locals.tenantId !== 'string' || !locals.tenantId)
+        return null;
+    return {
+        id,
+        tenantId: locals.tenantId,
+        scopes: Array.isArray(locals.permissions)
+            ? locals.permissions
+            : [],
+    };
+}
+/** The principal of the running async scope (the session's tenant context). */
+export function currentPrincipal() {
+    const ctx = getCurrentTenant();
+    if (!ctx?.userId || !ctx.tenantId)
+        return null;
+    return { id: ctx.userId, tenantId: ctx.tenantId };
+}
+/** For model methods: the owner of the current scope, or a refusal. */
+export function assertOwner() {
+    return requireOwner(currentPrincipal());
+}
+/**
+ * Run `fn` inside the verified principal's tenant context, so the owner check
+ * in model methods (`assertOwner`) sees exactly the principal a route
+ * verified, whatever async context the route runs in.
+ */
+export function runAs(principal, fn) {
+    return withTenant({
+        tenantId: principal.tenantId,
+        userId: principal.id,
+        permissions: new Set(principal.scopes ?? []),
+    }, fn);
+}

package/dist/lib/server/version-store.d.ts

@@ -0,0 +1,20 @@
+import type { DatabaseInterface } from '@happyvertical/sql';
+import type { VersionRecord, VersionStore } from '../../engine/index.ts';
+import { type App } from '../objects/App.ts';
+export declare const APP_SLUG = "app";
+export declare class ShellVersionStore implements VersionStore {
+    private readonly db;
+    constructor(db: DatabaseInterface);
+    private versions;
+    private apps;
+    private row;
+    /** The singleton App row, created on first use. */
+    appRow(): Promise<App>;
+    current(): Promise<number | null>;
+    setCurrent(version: number): Promise<void>;
+    get(version: number): Promise<VersionRecord | null>;
+    list(): Promise<VersionRecord[]>;
+    append(record: VersionRecord): Promise<void>;
+    markPurged(version: number): Promise<void>;
+    maxVersion(): Promise<number>;
+}

package/dist/lib/server/version-store.js

@@ -0,0 +1,115 @@
+import { AppCollection } from "../objects/App.js";
+import { AppVersionCollection, } from "../objects/AppVersion.js";
+export const APP_SLUG = 'app';
+function toRecord(row) {
+    const migration = row.migration
+        ? JSON.parse(row.migration)
+        : null;
+    if (migration && row.purged)
+        migration.purged = true;
+    return {
+        version: Number(row.version),
+        parent: Number(row.parent) < 0 ? null : Number(row.parent),
+        author: row.author,
+        summary: row.summary,
+        definition: JSON.parse(row.definition),
+        migration,
+        // the ORM may hydrate a timestamp-looking column as a Date
+        createdAt: row.createdAt instanceof Date
+            ? row.createdAt.toISOString()
+            : String(row.createdAt),
+    };
+}
+export class ShellVersionStore {
+    db;
+    constructor(db) {
+        this.db = db;
+    }
+    versions() {
+        return AppVersionCollection.create({ db: this.db });
+    }
+    apps() {
+        return AppCollection.create({ db: this.db });
+    }
+    async row(version) {
+        const rows = await (await this.versions()).list({
+            where: { version },
+            limit: 1,
+        });
+        return rows[0] ?? null;
+    }
+    /** The singleton App row, created on first use. */
+    async appRow() {
+        const apps = await this.apps();
+        const rows = await apps.list({ where: { slug: APP_SLUG }, limit: 1 });
+        if (rows[0])
+            return rows[0];
+        const created = await apps.create({
+            slug: APP_SLUG,
+            name: 'My app',
+            currentVersion: -1,
+            definition: '',
+        });
+        await created.save();
+        return created;
+    }
+    async current() {
+        const v = Number((await this.appRow()).currentVersion);
+        return v < 0 ? null : v;
+    }
+    async setCurrent(version) {
+        const rec = await this.row(version);
+        if (!rec)
+            throw new Error(`version ${version} is not stored`);
+        const app = await this.appRow();
+        app.currentVersion = version;
+        app.definition = rec.definition;
+        try {
+            app.name = JSON.parse(rec.definition).name ?? app.name;
+        }
+        catch {
+            /* keep the name */
+        }
+        await app.save();
+    }
+    async get(version) {
+        const row = await this.row(version);
+        return row ? toRecord(row) : null;
+    }
+    async list() {
+        const rows = await (await this.versions()).list({ limit: 100000 });
+        return rows.map(toRecord).sort((a, b) => a.version - b.version);
+    }
+    async append(record) {
+        if (await this.row(record.version))
+            throw new Error(`version ${record.version} already exists`);
+        const created = await (await this.versions()).create({
+            version: record.version,
+            parent: record.parent ?? -1,
+            author: record.author,
+            summary: record.summary,
+            definition: JSON.stringify(record.definition),
+            migration: record.migration ? JSON.stringify(record.migration) : '',
+            createdAt: record.createdAt,
+            purged: !!record.migration?.purged,
+        });
+        await created.save();
+    }
+    async markPurged(version) {
+        const row = await this.row(version);
+        if (!row)
+            return;
+        row.purged = true;
+        if (row.migration) {
+            row.migration = JSON.stringify({
+                ...JSON.parse(row.migration),
+                purged: true,
+            });
+        }
+        await row.save();
+    }
+    async maxVersion() {
+        const rows = await (await this.versions()).list({ limit: 100000 });
+        return rows.length ? Math.max(...rows.map((r) => Number(r.version))) : -1;
+    }
+}