@usestatemachines/cli 0.0.0-stage → 0.1.0

package/dist/config/project.d.ts

@@ -0,0 +1,21 @@
+import { z } from 'zod';
+import type { EffectOptions, Io } from '../io-types.js';
+declare const projectSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    organizationId: z.core.$ZodBranded<z.ZodString, "OrganizationId", "out">;
+    workspaceId: z.core.$ZodBranded<z.ZodString, "WorkspaceId", "out">;
+}, z.core.$strict>;
+export type ProjectLink = z.infer<typeof projectSchema>;
+export interface ProjectRepository {
+    read(): Promise<(ProjectLink & {
+        path: string;
+    }) | null>;
+    link(value: Omit<ProjectLink, 'version'>, force: boolean): Promise<ProjectLink & {
+        path: string;
+    }>;
+    unlink(): Promise<{
+        path: string | null;
+    }>;
+}
+export declare function createProjectRepository(io: Io, options: EffectOptions): ProjectRepository;
+export {};

package/dist/config/project.js

@@ -0,0 +1,105 @@
+import { dirname, join } from 'node:path';
+import { z } from 'zod';
+import { organizationIdSchema, workspaceIdSchema } from '../context-types.js';
+import { CliError } from '../errors.js';
+import { findProjectRoot } from '../project-roots.js';
+import { parseVersioned } from './schema.js';
+const projectSchema = z.strictObject({
+    version: z.literal(1),
+    organizationId: organizationIdSchema,
+    workspaceId: workspaceIdSchema,
+});
+export function createProjectRepository(io, options) {
+    async function read() {
+        const root = await findProjectRoot(io, options);
+        if (root === null) {
+            return null;
+        }
+        let directory = io.host.cwd;
+        while (true) {
+            const path = join(directory, '.statemachines', 'project.json');
+            const text = await io.files.read(path, options);
+            if (text !== null) {
+                return { ...parseVersioned(text, projectSchema), path };
+            }
+            if (directory === root || dirname(directory) === directory) {
+                return null;
+            }
+            directory = dirname(directory);
+        }
+    }
+    return {
+        read,
+        async link(value, force) {
+            const root = await findProjectRoot(io, options);
+            if (root === null) {
+                throw new CliError('cli.not_linked');
+            }
+            const path = join(root, '.statemachines', 'project.json');
+            return io.files.withLock(join(root, '.statemachines', '.lock'), options, async () => {
+                const links = [];
+                let directory = io.host.cwd;
+                while (true) {
+                    const candidate = join(directory, '.statemachines', 'project.json');
+                    const text = await io.files.read(candidate, options);
+                    if (text !== null) {
+                        links.push({
+                            ...parseVersioned(text, projectSchema),
+                            path: candidate,
+                        });
+                    }
+                    if (directory === root || dirname(directory) === directory) {
+                        break;
+                    }
+                    directory = dirname(directory);
+                }
+                if (!force &&
+                    links.some((existing) => existing.organizationId !== value.organizationId)) {
+                    throw new CliError('cli.organization_mismatch');
+                }
+                if (!force &&
+                    links.some((existing) => existing.workspaceId !== value.workspaceId)) {
+                    throw new CliError('cli.workspace_mismatch', {
+                        message: 'This repository is linked to another workspace in the same organization.',
+                        next: [
+                            {
+                                command: 'statemachines link --force',
+                                reason: 'Replace the repository link.',
+                            },
+                        ],
+                    });
+                }
+                const project = { version: 1, ...value };
+                const ignorePath = join(root, '.gitignore');
+                const ignore = (await io.files.read(ignorePath, options)) ?? '';
+                if (!ignore
+                    .split(/\r?\n/)
+                    .some((line) => /^(?:\/)?\.statemachines\/?$/.test(line.trim()))) {
+                    await io.files.atomicWrite(ignorePath, `${ignore}${ignore === '' || ignore.endsWith('\n') ? '' : '\n'}.statemachines\n`, 'public', options);
+                }
+                await io.files.atomicWrite(path, `${JSON.stringify(project, null, 2)}\n`, 'public', options);
+                if (force) {
+                    for (const existing of links) {
+                        if (existing.path !== path) {
+                            await io.files.remove(existing.path, options);
+                        }
+                    }
+                }
+                return { ...project, path };
+            });
+        },
+        async unlink() {
+            const root = await findProjectRoot(io, options);
+            if (root === null) {
+                return { path: null };
+            }
+            return io.files.withLock(join(root, '.statemachines', '.lock'), options, async () => {
+                const link = await read();
+                if (link !== null) {
+                    await io.files.remove(link.path, options);
+                }
+                return { path: link?.path ?? null };
+            });
+        },
+    };
+}