@house-rules/projects 0.0.0-stage → 0.1.0

package/dist/project/project.d.ts

@@ -0,0 +1,75 @@
+import { Schema } from "effect";
+export declare const Project: Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+    readonly slug: Schema.NonEmptyString;
+    readonly name: Schema.NonEmptyString;
+    readonly status: Schema.NonEmptyString;
+    readonly description: Schema.String;
+    readonly createdAt: Schema.Int;
+    readonly updatedAt: Schema.Int;
+}>;
+export type Project = typeof Project.Type;
+export declare const ProjectRef: Schema.Union<readonly [Schema.Struct<{
+    readonly id: Schema.NonEmptyString;
+}>, Schema.Struct<{
+    readonly slug: Schema.NonEmptyString;
+}>]>;
+export type ProjectRef = typeof ProjectRef.Type;
+export declare const NewProject: Schema.Struct<{
+    readonly slug: Schema.String;
+    readonly name: Schema.String;
+    readonly status: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+}>;
+export type NewProject = typeof NewProject.Type;
+export declare const ProjectPatch: Schema.Struct<{
+    readonly slug: Schema.optionalKey<Schema.String>;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly status: Schema.optionalKey<Schema.String>;
+    readonly description: Schema.optionalKey<Schema.String>;
+}>;
+export type ProjectPatch = typeof ProjectPatch.Type;
+export declare const ProjectFilter: Schema.Struct<{
+    readonly status: Schema.optionalKey<Schema.String>;
+}>;
+export type ProjectFilter = typeof ProjectFilter.Type;
+declare const ProjectNotFound_base: Schema.Class<ProjectNotFound, Schema.TaggedStruct<"ProjectNotFound", {
+    readonly kind: Schema.tag<"not_found">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectNotFound extends ProjectNotFound_base {
+}
+declare const ProjectSlugTaken_base: Schema.Class<ProjectSlugTaken, Schema.TaggedStruct<"ProjectSlugTaken", {
+    readonly kind: Schema.tag<"conflict">;
+    readonly slug: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectSlugTaken extends ProjectSlugTaken_base {
+}
+declare const ProjectInputInvalid_base: Schema.Class<ProjectInputInvalid, Schema.TaggedStruct<"ProjectInputInvalid", {
+    readonly kind: Schema.tag<"invalid">;
+    readonly field: Schema.Literals<readonly ["slug", "name", "status", "options"]>;
+    readonly message: Schema.String;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectInputInvalid extends ProjectInputInvalid_base {
+}
+declare const ProjectAccessDenied_base: Schema.Class<ProjectAccessDenied, Schema.TaggedStruct<"ProjectAccessDenied", {
+    readonly kind: Schema.tag<"forbidden">;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectAccessDenied extends ProjectAccessDenied_base {
+}
+declare const ProjectStoreUnavailable_base: Schema.Class<ProjectStoreUnavailable, Schema.TaggedStruct<"ProjectStoreUnavailable", {
+    readonly kind: Schema.tag<"unavailable">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectStoreUnavailable extends ProjectStoreUnavailable_base {
+    get message(): string;
+}
+declare const ProjectAccessUnavailable_base: Schema.Class<ProjectAccessUnavailable, Schema.TaggedStruct<"ProjectAccessUnavailable", {
+    readonly kind: Schema.tag<"unavailable">;
+    readonly cause: Schema.Defect;
+}>, import("effect/Cause").YieldableError>;
+export declare class ProjectAccessUnavailable extends ProjectAccessUnavailable_base {
+    get message(): string;
+}
+export declare const ProjectFailure: Schema.Union<readonly [typeof ProjectNotFound, typeof ProjectSlugTaken, typeof ProjectInputInvalid, typeof ProjectAccessDenied, typeof ProjectStoreUnavailable, typeof ProjectAccessUnavailable]>;
+export type ProjectFailure = typeof ProjectFailure.Type;
+export {};

package/dist/project/project.js

@@ -0,0 +1,71 @@
+import { errorKind } from "@house-rules/domain/contract";
+import { Schema } from "effect";
+export const Project = Schema.Struct({
+    id: Schema.NonEmptyString,
+    slug: Schema.NonEmptyString,
+    name: Schema.NonEmptyString,
+    status: Schema.NonEmptyString,
+    description: Schema.String,
+    createdAt: Schema.Int,
+    updatedAt: Schema.Int,
+});
+export const ProjectRef = Schema.Union([
+    Schema.Struct({ id: Schema.NonEmptyString }),
+    Schema.Struct({ slug: Schema.NonEmptyString }),
+]);
+export const NewProject = Schema.Struct({
+    slug: Schema.String,
+    name: Schema.String,
+    status: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+});
+export const ProjectPatch = Schema.Struct({
+    slug: Schema.optionalKey(Schema.String),
+    name: Schema.optionalKey(Schema.String),
+    status: Schema.optionalKey(Schema.String),
+    description: Schema.optionalKey(Schema.String),
+});
+export const ProjectFilter = Schema.Struct({ status: Schema.optionalKey(Schema.String) });
+export class ProjectNotFound extends Schema.TaggedError()("ProjectNotFound", {
+    kind: errorKind("not_found"),
+}) {
+}
+export class ProjectSlugTaken extends Schema.TaggedError()("ProjectSlugTaken", {
+    kind: errorKind("conflict"),
+    slug: Schema.String,
+}) {
+}
+export class ProjectInputInvalid extends Schema.TaggedError()("ProjectInputInvalid", {
+    kind: errorKind("invalid"),
+    field: Schema.Literals(["slug", "name", "status", "options"]),
+    message: Schema.String,
+}) {
+}
+export class ProjectAccessDenied extends Schema.TaggedError()("ProjectAccessDenied", {
+    kind: errorKind("forbidden"),
+}) {
+}
+export class ProjectStoreUnavailable extends Schema.TaggedError()("ProjectStoreUnavailable", {
+    kind: errorKind("unavailable"),
+    cause: Schema.Defect(),
+}) {
+    get message() {
+        return "Projects are unavailable. Try again shortly.";
+    }
+}
+export class ProjectAccessUnavailable extends Schema.TaggedError()("ProjectAccessUnavailable", {
+    kind: errorKind("unavailable"),
+    cause: Schema.Defect(),
+}) {
+    get message() {
+        return "Project access is unavailable. Try again shortly.";
+    }
+}
+export const ProjectFailure = Schema.Union([
+    ProjectNotFound,
+    ProjectSlugTaken,
+    ProjectInputInvalid,
+    ProjectAccessDenied,
+    ProjectStoreUnavailable,
+    ProjectAccessUnavailable,
+]);

package/dist/project/projects.d.ts

@@ -0,0 +1,135 @@
+import { type Actor } from "@house-rules/domain";
+import { Effect } from "effect";
+import type { ProjectStore } from "../storage.js";
+import type { ProjectAccess } from "./access.js";
+import type { ProjectsOptions } from "./options.js";
+import { ProjectAccessDenied, ProjectInputInvalid, ProjectNotFound, type ProjectRef } from "./project.js";
+export declare const makeProjects: (store: ProjectStore["Service"], access: ProjectAccess["Service"] | undefined, options: ProjectsOptions, pattern: RegExp) => {
+    create: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, input: {
+        readonly slug: string;
+        readonly name: string;
+        readonly status?: string;
+        readonly description?: string;
+    }) => Effect.Effect<{
+        project: {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        };
+        events: {
+            kind: "ProjectCreated";
+            project: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | ProjectAccessDenied | import("./project.js").ProjectAccessUnavailable | ProjectInputInvalid | ProjectNotFound | import("./project.js").ProjectSlugTaken | import("./project.js").ProjectStoreUnavailable, never>;
+    update: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, ref: {
+        readonly id: string;
+    } | {
+        readonly slug: string;
+    }, patch: {
+        readonly slug?: string;
+        readonly name?: string;
+        readonly status?: string;
+        readonly description?: string;
+    }) => Effect.Effect<{
+        project: {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        };
+        events: {
+            kind: "ProjectUpdated";
+            before: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+            after: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | ProjectAccessDenied | import("./project.js").ProjectAccessUnavailable | ProjectInputInvalid | ProjectNotFound | import("./project.js").ProjectSlugTaken | import("./project.js").ProjectStoreUnavailable, never>;
+    archive: (actor: Actor, ref: ProjectRef) => Effect.Effect<{
+        project: {
+            readonly id: string;
+            readonly slug: string;
+            readonly name: string;
+            readonly status: string;
+            readonly description: string;
+            readonly createdAt: number;
+            readonly updatedAt: number;
+        };
+        events: {
+            kind: "ProjectUpdated";
+            before: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+            after: {
+                id: string;
+                slug: string;
+                name: string;
+                status: string;
+                description: string;
+                createdAt: number;
+                updatedAt: number;
+            };
+        }[];
+    }, import("@house-rules/domain").NoOpenUnit | ProjectAccessDenied | import("./project.js").ProjectAccessUnavailable | ProjectInputInvalid | ProjectNotFound | import("./project.js").ProjectSlugTaken | import("./project.js").ProjectStoreUnavailable, never>;
+    show: (actor: Actor, ref: ProjectRef) => Effect.Effect<{
+        readonly id: string;
+        readonly slug: string;
+        readonly name: string;
+        readonly status: string;
+        readonly description: string;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    }, ProjectAccessDenied | import("./project.js").ProjectAccessUnavailable | ProjectNotFound | import("./project.js").ProjectStoreUnavailable, never>;
+    list: (actor: {
+        readonly id: string & import("effect/Brand").Brand<"ActorId">;
+    }, filter?: {
+        readonly status?: string;
+    } | undefined) => Effect.Effect<readonly {
+        readonly id: string;
+        readonly slug: string;
+        readonly name: string;
+        readonly status: string;
+        readonly description: string;
+        readonly createdAt: number;
+        readonly updatedAt: number;
+    }[], import("./project.js").ProjectAccessUnavailable | ProjectInputInvalid | import("./project.js").ProjectStoreUnavailable, never>;
+};

package/dist/project/projects.js

@@ -0,0 +1,98 @@
+import { UnitOfWork } from "@house-rules/domain";
+import { DateTime, Effect, Random, Schema } from "effect";
+import { ProjectAccessDenied, ProjectInputInvalid, ProjectNotFound, } from "./project.js";
+export const makeProjects = (store, access, options, pattern) => {
+    const decodeStatus = (status) => Schema.decodeEffect(Schema.Literals(options.statuses))(status).pipe(Effect.mapError(() => new ProjectInputInvalid({
+        field: "status",
+        message: "Status must be one of the configured project statuses.",
+    })));
+    const decodeName = (name) => Schema.decodeEffect(Schema.NonEmptyString.check(Schema.isMaxLength(200)))(name).pipe(Effect.mapError(() => new ProjectInputInvalid({
+        field: "name",
+        message: "Name must contain 1 to 200 characters.",
+    })));
+    const decodeSlug = (slug) => Schema.decodeEffect(Schema.NonEmptyString.check(Schema.isMaxLength(options.slug.maxLength), Schema.isPattern(pattern)))(slug).pipe(Effect.mapError(() => new ProjectInputInvalid({
+        field: "slug",
+        message: `Slug must contain 1 to ${options.slug.maxLength} characters and match the app's slug format.`,
+    })));
+    const slugOf = (slug) => {
+        const trimmed = options.slug.trim ? slug.trim() : slug;
+        return options.slug.lowercase ? trimmed.toLowerCase() : trimmed;
+    };
+    const requireAccess = Effect.fn("Projects.requireAccess")(function* (actor, id, write) {
+        if (access === undefined)
+            return;
+        const relation = yield* access.access(actor, id);
+        if (relation === "write" || (!write && relation === "read"))
+            return;
+        return yield* id === null ? new ProjectAccessDenied() : new ProjectNotFound();
+    });
+    const find = Effect.fn("Projects.find")(function* (actor, ref, write) {
+        const normalized = "slug" in ref ? { slug: slugOf(ref.slug) } : ref;
+        const project = yield* store.get(normalized);
+        if (project === undefined)
+            return yield* new ProjectNotFound();
+        yield* requireAccess(actor, project.id, write);
+        return project;
+    });
+    const change = Effect.fn("Projects.change")(function* (actor, ref, patch) {
+        yield* UnitOfWork.required;
+        yield* store.lock;
+        const before = yield* find(actor, ref, true);
+        const slug = yield* decodeSlug(slugOf(patch.slug ?? before.slug));
+        const name = yield* decodeName((patch.name ?? before.name).trim());
+        const status = yield* decodeStatus(patch.status ?? before.status);
+        const description = patch.description ?? before.description;
+        if (slug === before.slug &&
+            name === before.name &&
+            status === before.status &&
+            description === before.description) {
+            return { project: before, events: [] };
+        }
+        const after = {
+            ...before,
+            slug,
+            name,
+            status,
+            description,
+            updatedAt: DateTime.toEpochMillis(yield* DateTime.now),
+        };
+        yield* store.replace(after);
+        return {
+            project: after,
+            events: [{ kind: "ProjectUpdated", before: { ...before }, after: { ...after } }],
+        };
+    });
+    return {
+        create: Effect.fn("Projects.create")(function* (actor, input) {
+            yield* UnitOfWork.required;
+            yield* requireAccess(actor, null, true);
+            const slug = yield* decodeSlug(slugOf(input.slug));
+            const name = yield* decodeName(input.name.trim());
+            const status = yield* decodeStatus(input.status ?? options.defaultStatus);
+            const now = DateTime.toEpochMillis(yield* DateTime.now);
+            const id = yield* Effect.all(Array.from({ length: 4 }, () => Random.nextIntBetween(0, 0xffff_ffff))).pipe(Effect.map((words) => words.map((word) => word.toString(16).padStart(8, "0")).join("")));
+            const project = {
+                id,
+                slug,
+                name,
+                status,
+                description: input.description ?? "",
+                createdAt: now,
+                updatedAt: now,
+            };
+            yield* store.insert(project);
+            return {
+                project,
+                events: [{ kind: "ProjectCreated", project: { ...project } }],
+            };
+        }),
+        update: change,
+        archive: (actor, ref) => change(actor, ref, { status: options.archivedStatus }),
+        show: (actor, ref) => find(actor, ref, false),
+        list: Effect.fn("Projects.list")(function* (actor, filter = {}) {
+            const status = filter.status === undefined ? undefined : yield* decodeStatus(filter.status);
+            const ids = access === undefined ? undefined : yield* access.visibleProjects(actor);
+            return yield* store.list(status, ids);
+        }),
+    };
+};

package/dist/storage.d.ts

@@ -0,0 +1,13 @@
+import type { NoOpenUnit } from "@house-rules/domain";
+import { Context, type Effect } from "effect";
+import type { Project, ProjectRef, ProjectSlugTaken, ProjectStoreUnavailable } from "./project/project.js";
+declare const ProjectStore_base: Context.ServiceClass<ProjectStore, "@house-rules/projects/ProjectStore", {
+    readonly lock: Effect.Effect<void, ProjectStoreUnavailable | NoOpenUnit>;
+    readonly get: (ref: ProjectRef) => Effect.Effect<Project | undefined, ProjectStoreUnavailable>;
+    readonly list: (status?: string, visibleIds?: ReadonlyArray<string>) => Effect.Effect<ReadonlyArray<Project>, ProjectStoreUnavailable>;
+    readonly insert: (project: Project) => Effect.Effect<void, ProjectStoreUnavailable | ProjectSlugTaken | NoOpenUnit>;
+    readonly replace: (project: Project) => Effect.Effect<void, ProjectStoreUnavailable | ProjectSlugTaken | NoOpenUnit>;
+}>;
+export declare class ProjectStore extends ProjectStore_base {
+}
+export {};

package/dist/storage.js

@@ -0,0 +1,3 @@
+import { Context } from "effect";
+export class ProjectStore extends Context.Service()("@house-rules/projects/ProjectStore") {
+}

package/migrations/0001_projects.sql

@@ -0,0 +1,9 @@
+CREATE TABLE projects (
+  id text PRIMARY KEY,
+  slug text NOT NULL UNIQUE,
+  name text NOT NULL,
+  status text NOT NULL,
+  description text NOT NULL,
+  created_at bigint NOT NULL,
+  updated_at bigint NOT NULL
+);

package/migrations/0002_projects_view.sql

@@ -0,0 +1,2 @@
+CREATE VIEW projects_view AS
+SELECT id, slug, name, status, description, created_at, updated_at FROM projects;

package/package.json

@@ -1,6 +1,60 @@
 {
   "name": "@house-rules/projects",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Configurable project records with unique slugs and returned facts.",
+  "license": "MIT",
+  "type": "module",
+  "files": [
+    "dist",
+    "migrations",
+    "AGENTS.md",
+    "README.md"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    },
+    "./contract": {
+      "types": "./dist/contract.d.ts",
+      "default": "./dist/contract.js"
+    }
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/JakubSzwajka/house-rules.git",
+    "directory": "packages/projects"
+  },
+  "bugs": {
+    "url": "https://github.com/JakubSzwajka/house-rules/issues"
+  },
+  "homepage": "https://github.com/JakubSzwajka/house-rules",
+  "houseRules": {
+    "migrations": "migrations"
+  },
+  "peerDependencies": {
+    "@house-rules/application": "0.2.0",
+    "@house-rules/domain": "0.2.0",
+    "effect": "4.0.3"
+  },
+  "devDependencies": {
+    "@effect/platform-node": "4.0.3",
+    "@effect/platform-node-shared": "4.0.3",
+    "@effect/sql-pg": "4.0.3",
+    "@effect/vitest": "4.0.3",
+    "@house-rules/application": "0.2.0",
+    "@house-rules/domain": "0.2.0",
+    "@house-rules/migrations": "0.4.0",
+    "effect": "4.0.3",
+    "typescript": "7.0.2",
+    "vitest": "5.0.1"
+  },
+  "scripts": {
+    "build": "tsc --project tsconfig.build.json",
+    "typecheck": "tsc --project tsconfig.json",
+    "test": "varlock run --path ../../ -- vitest run"
+  }
 }