@baseworks/organization 0.2.0

package/dist/index.d.ts

@@ -0,0 +1,199 @@
+export { environments, organizations, projects, workspaces } from './schema/sqlite/index.js';
+export { generateId, generateShortId } from '@baseworks/core';
+import 'drizzle-orm/sqlite-core';
+
+interface Organization {
+    id: string;
+    shortId: string;
+    slug: string;
+    name: string;
+    metadata: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface NewOrganization {
+    id?: string;
+    shortId?: string;
+    slug?: string;
+    name: string;
+    metadata?: string | null;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface Workspace {
+    id: string;
+    organizationId: string;
+    shortId: string;
+    slug: string;
+    name: string;
+    isDefault: boolean;
+    createdAt: number;
+    updatedAt: number;
+}
+interface NewWorkspace {
+    id?: string;
+    organizationId: string;
+    shortId?: string;
+    slug?: string;
+    name: string;
+    isDefault?: boolean;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface Project {
+    id: string;
+    workspaceId: string;
+    shortId: string;
+    slug: string;
+    name: string;
+    isDefault: boolean;
+    metadata: string | null;
+    createdAt: number;
+    updatedAt: number;
+}
+interface NewProject {
+    id?: string;
+    workspaceId: string;
+    shortId?: string;
+    slug?: string;
+    name: string;
+    isDefault?: boolean;
+    metadata?: string | null;
+    createdAt?: number;
+    updatedAt?: number;
+}
+interface Environment {
+    id: string;
+    projectId: string;
+    shortId: string;
+    slug: string;
+    name: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface NewEnvironment {
+    id?: string;
+    projectId: string;
+    shortId?: string;
+    slug?: string;
+    name: string;
+    createdAt?: number;
+    updatedAt?: number;
+}
+
+type AnyDB$4 = any;
+declare function createOrganizationRepo(db: AnyDB$4, schema: {
+    organizations: any;
+}): {
+    create(data: {
+        name: string;
+        slug?: string;
+        id?: string;
+    }): Promise<Organization>;
+    findById(id: string): Promise<Organization | undefined>;
+    findByShortId(shortId: string): Promise<Organization | undefined>;
+    findBySlug(slug: string): Promise<Organization | undefined>;
+    findByRef(ref: string): Promise<Organization | undefined>;
+    isSlugAvailable(slug: string): Promise<boolean>;
+    claimSlug(id: string, slug: string): Promise<void>;
+    update(id: string, data: {
+        name?: string;
+        slug?: string;
+        metadata?: string | null;
+    }): Promise<Organization | undefined>;
+    patchMetadata(id: string, patch: Record<string, unknown>): Promise<Organization | undefined>;
+    delete(id: string): Promise<void>;
+    listAll(): Promise<Organization[]>;
+    hardDelete(id: string): Promise<void>;
+};
+type OrganizationRepo = ReturnType<typeof createOrganizationRepo>;
+
+type AnyDB$3 = any;
+declare function createWorkspaceRepo(db: AnyDB$3, schema: {
+    workspaces: any;
+}): {
+    create(data: {
+        organizationId: string;
+        name: string;
+        slug?: string;
+        isDefault?: boolean;
+        id?: string;
+    }): Promise<Workspace>;
+    findById(id: string): Promise<Workspace | undefined>;
+    findByShortId(shortId: string): Promise<Workspace | undefined>;
+    findBySlug(organizationId: string, slug: string): Promise<Workspace | undefined>;
+    findByRef(organizationId: string, ref: string): Promise<Workspace | undefined>;
+    listByOrg(organizationId: string): Promise<Workspace[]>;
+    findDefault(organizationId: string): Promise<Workspace | undefined>;
+    update(id: string, data: {
+        name?: string;
+    }): Promise<Workspace | undefined>;
+    delete(id: string): Promise<void>;
+};
+type WorkspaceRepo = ReturnType<typeof createWorkspaceRepo>;
+
+type AnyDB$2 = any;
+declare function createProjectRepo(db: AnyDB$2, schema: {
+    projects: any;
+}): {
+    create(data: {
+        workspaceId: string;
+        name: string;
+        slug?: string;
+        isDefault?: boolean;
+        id?: string;
+    }): Promise<Project>;
+    findById(id: string): Promise<Project | undefined>;
+    findByShortId(shortId: string): Promise<Project | undefined>;
+    findBySlug(workspaceId: string, slug: string): Promise<Project | undefined>;
+    findByRef(workspaceId: string, ref: string): Promise<Project | undefined>;
+    listByWorkspace(workspaceId: string): Promise<Project[]>;
+    findDefault(workspaceId: string): Promise<Project | undefined>;
+    update(id: string, data: {
+        name?: string;
+    }): Promise<Project | undefined>;
+    delete(id: string): Promise<void>;
+    getMetadata(id: string): Promise<Record<string, unknown>>;
+    patchMetadata(id: string, patch: Record<string, unknown>): Promise<Record<string, unknown>>;
+};
+type ProjectRepo = ReturnType<typeof createProjectRepo>;
+
+type AnyDB$1 = any;
+declare function createEnvironmentRepo(db: AnyDB$1, schema: {
+    environments: any;
+}): {
+    create(data: {
+        projectId: string;
+        name: string;
+        slug?: string;
+        id?: string;
+    }): Promise<Environment>;
+    findById(id: string): Promise<Environment | undefined>;
+    findByShortId(shortId: string): Promise<Environment | undefined>;
+    findByIdentifier(projectId: string, identifier: string): Promise<Environment | undefined>;
+    findByRef(projectId: string, ref: string): Promise<Environment | undefined>;
+    listByProject(projectId: string): Promise<Environment[]>;
+    update(id: string, data: {
+        name?: string;
+        slug?: string;
+    }): Promise<Environment | undefined>;
+    delete(id: string): Promise<void>;
+};
+type EnvironmentRepo = ReturnType<typeof createEnvironmentRepo>;
+
+type AnyDB = any;
+type AnySchema = any;
+interface OrganizationBootstrapResult {
+    organization: Organization;
+    defaultWorkspace: Workspace;
+    defaultProject: Project;
+}
+interface OrganizationBootstrapInput {
+    name: string;
+    slug?: string;
+    workspaceName?: string;
+    projectName?: string;
+}
+declare function createOrganizationWithDefaults(db: AnyDB, schema: AnySchema, input: OrganizationBootstrapInput): Promise<OrganizationBootstrapResult>;
+
+export { type Environment, type EnvironmentRepo, type NewEnvironment, type NewOrganization, type NewProject, type NewWorkspace, type Organization, type OrganizationBootstrapInput, type OrganizationBootstrapResult, type OrganizationRepo, type Project, type ProjectRepo, type Workspace, type WorkspaceRepo, createEnvironmentRepo, createOrganizationRepo, createOrganizationWithDefaults, createProjectRepo, createWorkspaceRepo };

package/dist/index.js

@@ -0,0 +1,335 @@
+import {
+  environments,
+  organizations,
+  projects,
+  workspaces
+} from "./chunk-5UCSEIJS.js";
+
+// src/repo/organizations.ts
+import { eq, desc } from "drizzle-orm";
+import { generateId, generateShortId, generateSlug } from "@baseworks/core";
+function createOrganizationRepo(db, schema) {
+  const { organizations: organizations2 } = schema;
+  return {
+    async create(data) {
+      const now = Date.now();
+      const shortId = generateShortId();
+      const row = {
+        id: data.id ?? generateId(),
+        shortId,
+        slug: data.slug ?? generateSlug(data.name),
+        name: data.name,
+        metadata: null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(organizations2).values(row);
+      return row;
+    },
+    async findById(id) {
+      const rows = await db.select().from(organizations2).where(eq(organizations2.id, id)).limit(1);
+      return rows[0];
+    },
+    async findByShortId(shortId) {
+      const rows = await db.select().from(organizations2).where(eq(organizations2.shortId, shortId)).limit(1);
+      return rows[0];
+    },
+    async findBySlug(slug) {
+      const rows = await db.select().from(organizations2).where(eq(organizations2.slug, slug)).limit(1);
+      return rows[0];
+    },
+    async findByRef(ref) {
+      const bySlug = await db.select().from(organizations2).where(eq(organizations2.slug, ref)).limit(1);
+      if (bySlug[0]) return bySlug[0];
+      const byShortId = await db.select().from(organizations2).where(eq(organizations2.shortId, ref)).limit(1);
+      return byShortId[0];
+    },
+    async isSlugAvailable(slug) {
+      const rows = await db.select({ id: organizations2.id }).from(organizations2).where(eq(organizations2.slug, slug)).limit(1);
+      return rows.length === 0;
+    },
+    async claimSlug(id, slug) {
+      await db.update(organizations2).set({ slug, updatedAt: Date.now() }).where(eq(organizations2.id, id));
+    },
+    async update(id, data) {
+      await db.update(organizations2).set({ ...data, updatedAt: Date.now() }).where(eq(organizations2.id, id));
+      const rows = await db.select().from(organizations2).where(eq(organizations2.id, id)).limit(1);
+      return rows[0];
+    },
+    async patchMetadata(id, patch) {
+      const rows = await db.select().from(organizations2).where(eq(organizations2.id, id)).limit(1);
+      const org = rows[0];
+      if (!org) return void 0;
+      const current = org.metadata ? JSON.parse(org.metadata) : {};
+      const merged = { ...current };
+      for (const [k, v] of Object.entries(patch)) {
+        if (v === null) delete merged[k];
+        else merged[k] = v;
+      }
+      await db.update(organizations2).set({ metadata: JSON.stringify(merged), updatedAt: Date.now() }).where(eq(organizations2.id, id));
+      const updated = await db.select().from(organizations2).where(eq(organizations2.id, id)).limit(1);
+      return updated[0];
+    },
+    async delete(id) {
+      await db.delete(organizations2).where(eq(organizations2.id, id));
+    },
+    async listAll() {
+      return db.select().from(organizations2).orderBy(desc(organizations2.createdAt));
+    },
+    async hardDelete(id) {
+      await db.delete(organizations2).where(eq(organizations2.id, id));
+    }
+  };
+}
+
+// src/repo/workspaces.ts
+import { and, eq as eq2 } from "drizzle-orm";
+import { generateId as generateId2, generateShortId as generateShortId2, generateSlug as generateSlug2 } from "@baseworks/core";
+async function resolveSlug(db, workspacesTable, organizationId, base) {
+  let slug = base;
+  let i = 2;
+  while (true) {
+    const rows = await db.select({ id: workspacesTable.id }).from(workspacesTable).where(and(eq2(workspacesTable.organizationId, organizationId), eq2(workspacesTable.slug, slug))).limit(1);
+    if (rows.length === 0) return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createWorkspaceRepo(db, schema) {
+  const { workspaces: workspaces2 } = schema;
+  return {
+    async create(data) {
+      const now = Date.now();
+      const base = data.slug ?? generateSlug2(data.name);
+      const slug = await resolveSlug(db, workspaces2, data.organizationId, base);
+      const row = {
+        id: data.id ?? generateId2(),
+        organizationId: data.organizationId,
+        shortId: generateShortId2(),
+        slug,
+        name: data.name,
+        isDefault: data.isDefault ?? false,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(workspaces2).values(row);
+      return row;
+    },
+    async findById(id) {
+      const rows = await db.select().from(workspaces2).where(eq2(workspaces2.id, id)).limit(1);
+      return rows[0];
+    },
+    async findByShortId(shortId) {
+      const rows = await db.select().from(workspaces2).where(eq2(workspaces2.shortId, shortId)).limit(1);
+      return rows[0];
+    },
+    async findBySlug(organizationId, slug) {
+      const rows = await db.select().from(workspaces2).where(and(eq2(workspaces2.organizationId, organizationId), eq2(workspaces2.slug, slug))).limit(1);
+      return rows[0];
+    },
+    async findByRef(organizationId, ref) {
+      const bySlug = await db.select().from(workspaces2).where(and(eq2(workspaces2.organizationId, organizationId), eq2(workspaces2.slug, ref))).limit(1);
+      if (bySlug[0]) return bySlug[0];
+      const byShortId = await db.select().from(workspaces2).where(and(eq2(workspaces2.organizationId, organizationId), eq2(workspaces2.shortId, ref))).limit(1);
+      return byShortId[0];
+    },
+    async listByOrg(organizationId) {
+      return db.select().from(workspaces2).where(eq2(workspaces2.organizationId, organizationId));
+    },
+    async findDefault(organizationId) {
+      const rows = await db.select().from(workspaces2).where(and(eq2(workspaces2.organizationId, organizationId), eq2(workspaces2.isDefault, true))).limit(1);
+      return rows[0];
+    },
+    async update(id, data) {
+      await db.update(workspaces2).set({ ...data, updatedAt: Date.now() }).where(eq2(workspaces2.id, id));
+      const rows = await db.select().from(workspaces2).where(eq2(workspaces2.id, id)).limit(1);
+      return rows[0];
+    },
+    async delete(id) {
+      await db.delete(workspaces2).where(eq2(workspaces2.id, id));
+    }
+  };
+}
+
+// src/repo/projects.ts
+import { and as and2, eq as eq3 } from "drizzle-orm";
+import { generateId as generateId3, generateShortId as generateShortId3, generateSlug as generateSlug3 } from "@baseworks/core";
+async function resolveSlug2(db, projectsTable, workspaceId, base) {
+  let slug = base;
+  let i = 2;
+  while (true) {
+    const rows = await db.select({ id: projectsTable.id }).from(projectsTable).where(and2(eq3(projectsTable.workspaceId, workspaceId), eq3(projectsTable.slug, slug))).limit(1);
+    if (rows.length === 0) return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createProjectRepo(db, schema) {
+  const { projects: projects2 } = schema;
+  return {
+    async create(data) {
+      const now = Date.now();
+      const base = data.slug ?? generateSlug3(data.name);
+      const slug = await resolveSlug2(db, projects2, data.workspaceId, base);
+      const row = {
+        id: data.id ?? generateId3(),
+        workspaceId: data.workspaceId,
+        shortId: generateShortId3(),
+        slug,
+        name: data.name,
+        isDefault: data.isDefault ?? false,
+        metadata: null,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(projects2).values(row);
+      return row;
+    },
+    async findById(id) {
+      const rows = await db.select().from(projects2).where(eq3(projects2.id, id)).limit(1);
+      return rows[0];
+    },
+    async findByShortId(shortId) {
+      const rows = await db.select().from(projects2).where(eq3(projects2.shortId, shortId)).limit(1);
+      return rows[0];
+    },
+    async findBySlug(workspaceId, slug) {
+      const rows = await db.select().from(projects2).where(and2(eq3(projects2.workspaceId, workspaceId), eq3(projects2.slug, slug))).limit(1);
+      return rows[0];
+    },
+    async findByRef(workspaceId, ref) {
+      const bySlug = await db.select().from(projects2).where(and2(eq3(projects2.workspaceId, workspaceId), eq3(projects2.slug, ref))).limit(1);
+      if (bySlug[0]) return bySlug[0];
+      const byShortId = await db.select().from(projects2).where(and2(eq3(projects2.workspaceId, workspaceId), eq3(projects2.shortId, ref))).limit(1);
+      return byShortId[0];
+    },
+    async listByWorkspace(workspaceId) {
+      return db.select().from(projects2).where(eq3(projects2.workspaceId, workspaceId));
+    },
+    async findDefault(workspaceId) {
+      const rows = await db.select().from(projects2).where(and2(eq3(projects2.workspaceId, workspaceId), eq3(projects2.isDefault, true))).limit(1);
+      return rows[0];
+    },
+    async update(id, data) {
+      await db.update(projects2).set({ ...data, updatedAt: Date.now() }).where(eq3(projects2.id, id));
+      const rows = await db.select().from(projects2).where(eq3(projects2.id, id)).limit(1);
+      return rows[0];
+    },
+    async delete(id) {
+      await db.delete(projects2).where(eq3(projects2.id, id));
+    },
+    async getMetadata(id) {
+      const rows = await db.select({ metadata: projects2.metadata }).from(projects2).where(eq3(projects2.id, id)).limit(1);
+      const row = rows[0];
+      if (!row?.metadata) return {};
+      try {
+        return JSON.parse(row.metadata);
+      } catch {
+        return {};
+      }
+    },
+    async patchMetadata(id, patch) {
+      const existing = await this.getMetadata(id);
+      const next = { ...existing };
+      for (const [k, v] of Object.entries(patch)) {
+        if (v === null) delete next[k];
+        else next[k] = v;
+      }
+      await db.update(projects2).set({ metadata: JSON.stringify(next), updatedAt: Date.now() }).where(eq3(projects2.id, id));
+      return next;
+    }
+  };
+}
+
+// src/repo/environments.ts
+import { and as and3, eq as eq4, or } from "drizzle-orm";
+import { generateId as generateId4, generateShortId as generateShortId4, generateSlug as generateSlug4 } from "@baseworks/core";
+async function resolveSlug3(db, envsTable, projectId, base) {
+  let slug = base;
+  let i = 2;
+  while (true) {
+    const rows = await db.select({ id: envsTable.id }).from(envsTable).where(and3(eq4(envsTable.projectId, projectId), eq4(envsTable.slug, slug))).limit(1);
+    if (rows.length === 0) return slug;
+    slug = `${base}-${i++}`;
+  }
+}
+function createEnvironmentRepo(db, schema) {
+  const { environments: environments2 } = schema;
+  return {
+    async create(data) {
+      const now = Date.now();
+      const base = data.slug ?? generateSlug4(data.name);
+      const slug = await resolveSlug3(db, environments2, data.projectId, base);
+      const row = {
+        id: data.id ?? generateId4(),
+        projectId: data.projectId,
+        shortId: generateShortId4(),
+        slug,
+        name: data.name,
+        createdAt: now,
+        updatedAt: now
+      };
+      await db.insert(environments2).values(row);
+      return row;
+    },
+    async findById(id) {
+      const rows = await db.select().from(environments2).where(eq4(environments2.id, id)).limit(1);
+      return rows[0];
+    },
+    async findByShortId(shortId) {
+      const rows = await db.select().from(environments2).where(eq4(environments2.shortId, shortId)).limit(1);
+      return rows[0];
+    },
+    async findByIdentifier(projectId, identifier) {
+      const rows = await db.select().from(environments2).where(and3(eq4(environments2.projectId, projectId), or(eq4(environments2.shortId, identifier), eq4(environments2.slug, identifier)))).limit(1);
+      return rows[0];
+    },
+    async findByRef(projectId, ref) {
+      return this.findByIdentifier(projectId, ref);
+    },
+    async listByProject(projectId) {
+      return db.select().from(environments2).where(eq4(environments2.projectId, projectId));
+    },
+    async update(id, data) {
+      await db.update(environments2).set({ ...data, updatedAt: Date.now() }).where(eq4(environments2.id, id));
+      const rows = await db.select().from(environments2).where(eq4(environments2.id, id)).limit(1);
+      return rows[0];
+    },
+    async delete(id) {
+      await db.delete(environments2).where(eq4(environments2.id, id));
+    }
+  };
+}
+
+// src/operations/bootstrap.ts
+async function createOrganizationWithDefaults(db, schema, input) {
+  const orgRepo = createOrganizationRepo(db, schema);
+  const workspaceRepo = createWorkspaceRepo(db, schema);
+  const projectRepo = createProjectRepo(db, schema);
+  const organization = await orgRepo.create({ name: input.name, slug: input.slug });
+  const defaultWorkspace = await workspaceRepo.create({
+    organizationId: organization.id,
+    name: input.workspaceName ?? "Default",
+    isDefault: true
+  });
+  const defaultProject = await projectRepo.create({
+    workspaceId: defaultWorkspace.id,
+    name: input.projectName ?? "Default",
+    isDefault: true
+  });
+  return { organization, defaultWorkspace, defaultProject };
+}
+
+// src/index.ts
+import { generateId as generateId5, generateShortId as generateShortId5 } from "@baseworks/core";
+export {
+  createEnvironmentRepo,
+  createOrganizationRepo,
+  createOrganizationWithDefaults,
+  createProjectRepo,
+  createWorkspaceRepo,
+  environments,
+  generateId5 as generateId,
+  generateShortId5 as generateShortId,
+  organizations,
+  projects,
+  workspaces
+};