@baseworks/organization 0.2.0

package/src/index.ts

@@ -0,0 +1,5 @@
+export * from './schema';
+export * from './types';
+export * from './repo';
+export * from './operations/bootstrap';
+export { generateId, generateShortId } from '@baseworks/core';

package/src/operations/bootstrap.ts

@@ -0,0 +1,50 @@
+import { createOrganizationRepo } from '../repo/organizations.js'
+import { createWorkspaceRepo }    from '../repo/workspaces.js'
+import { createProjectRepo }      from '../repo/projects.js'
+import type { Organization, Workspace, Project } from '../types.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDB    = any
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnySchema = any
+
+export interface OrganizationBootstrapResult {
+  organization:     Organization
+  defaultWorkspace: Workspace
+  defaultProject:   Project
+}
+
+export interface OrganizationBootstrapInput {
+  name:          string
+  slug?:         string
+  workspaceName?: string
+  projectName?:  string
+}
+
+// Creates org + default workspace + default project in sequence.
+// Wrap in a db.transaction() at the call site if atomicity is required.
+export async function createOrganizationWithDefaults(
+  db:     AnyDB,
+  schema: AnySchema,
+  input:  OrganizationBootstrapInput,
+): Promise<OrganizationBootstrapResult> {
+  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 }
+}

package/src/repo/environments.ts

@@ -0,0 +1,82 @@
+import { and, eq, or } from 'drizzle-orm'
+import { generateId, generateShortId, generateSlug } from '@baseworks/core'
+import type { Environment } from '../types.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDB = any
+
+async function resolveSlug(db: AnyDB, envsTable: any, projectId: string, base: string): Promise<string> {
+  let slug = base
+  let i    = 2
+  while (true) {
+    const rows = await db
+      .select({ id: envsTable.id })
+      .from(envsTable)
+      .where(and(eq(envsTable.projectId, projectId), eq(envsTable.slug, slug)))
+      .limit(1)
+    if (rows.length === 0) return slug
+    slug = `${base}-${i++}`
+  }
+}
+
+export function createEnvironmentRepo(db: AnyDB, schema: { environments: any }) {
+  const { environments } = schema
+
+  return {
+    async create(data: { projectId: string; name: string; slug?: string; id?: string }): Promise<Environment> {
+      const now  = Date.now()
+      const base = data.slug ?? generateSlug(data.name)
+      const slug = await resolveSlug(db, environments, data.projectId, base)
+      const row  = {
+        id:        data.id ?? generateId(),
+        projectId: data.projectId,
+        shortId:   generateShortId(),
+        slug,
+        name:      data.name,
+        createdAt: now,
+        updatedAt: now,
+      }
+      await db.insert(environments).values(row)
+      return row
+    },
+
+    async findById(id: string): Promise<Environment | undefined> {
+      const rows = await db.select().from(environments).where(eq(environments.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async findByShortId(shortId: string): Promise<Environment | undefined> {
+      const rows = await db.select().from(environments).where(eq(environments.shortId, shortId)).limit(1)
+      return rows[0]
+    },
+
+    async findByIdentifier(projectId: string, identifier: string): Promise<Environment | undefined> {
+      const rows = await db
+        .select()
+        .from(environments)
+        .where(and(eq(environments.projectId, projectId), or(eq(environments.shortId, identifier), eq(environments.slug, identifier))))
+        .limit(1)
+      return rows[0]
+    },
+
+    async findByRef(projectId: string, ref: string): Promise<Environment | undefined> {
+      return this.findByIdentifier(projectId, ref)
+    },
+
+    async listByProject(projectId: string): Promise<Environment[]> {
+      return db.select().from(environments).where(eq(environments.projectId, projectId))
+    },
+
+    async update(id: string, data: { name?: string; slug?: string }): Promise<Environment | undefined> {
+      await db.update(environments).set({ ...data, updatedAt: Date.now() }).where(eq(environments.id, id))
+      const rows = await db.select().from(environments).where(eq(environments.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async delete(id: string): Promise<void> {
+      await db.delete(environments).where(eq(environments.id, id))
+    },
+  }
+}
+
+export type EnvironmentRepo = ReturnType<typeof createEnvironmentRepo>

package/src/repo/index.ts

@@ -0,0 +1,9 @@
+export { createOrganizationRepo } from './organizations.js'
+export { createWorkspaceRepo }    from './workspaces.js'
+export { createProjectRepo }      from './projects.js'
+export { createEnvironmentRepo }  from './environments.js'
+
+export type { OrganizationRepo }  from './organizations.js'
+export type { WorkspaceRepo }     from './workspaces.js'
+export type { ProjectRepo }       from './projects.js'
+export type { EnvironmentRepo }   from './environments.js'

package/src/repo/organizations.ts

@@ -0,0 +1,96 @@
+import { eq, desc } from 'drizzle-orm'
+import { generateId, generateShortId, generateSlug } from '@baseworks/core'
+import type { Organization } from '../types.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDB = any
+
+export function createOrganizationRepo(db: AnyDB, schema: { organizations: any }) {
+  const { organizations } = schema
+
+  return {
+    async create(data: { name: string; slug?: string; id?: string }): Promise<Organization> {
+      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(organizations).values(row)
+      return row
+    },
+
+    async findById(id: string): Promise<Organization | undefined> {
+      const rows = await db.select().from(organizations).where(eq(organizations.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async findByShortId(shortId: string): Promise<Organization | undefined> {
+      const rows = await db.select().from(organizations).where(eq(organizations.shortId, shortId)).limit(1)
+      return rows[0]
+    },
+
+    async findBySlug(slug: string): Promise<Organization | undefined> {
+      const rows = await db.select().from(organizations).where(eq(organizations.slug, slug)).limit(1)
+      return rows[0]
+    },
+
+    async findByRef(ref: string): Promise<Organization | undefined> {
+      const bySlug = await db.select().from(organizations).where(eq(organizations.slug, ref)).limit(1)
+      if (bySlug[0]) return bySlug[0]
+      const byShortId = await db.select().from(organizations).where(eq(organizations.shortId, ref)).limit(1)
+      return byShortId[0]
+    },
+
+    async isSlugAvailable(slug: string): Promise<boolean> {
+      const rows = await db.select({ id: organizations.id }).from(organizations).where(eq(organizations.slug, slug)).limit(1)
+      return rows.length === 0
+    },
+
+    async claimSlug(id: string, slug: string): Promise<void> {
+      await db.update(organizations).set({ slug, updatedAt: Date.now() }).where(eq(organizations.id, id))
+    },
+
+    async update(id: string, data: { name?: string; slug?: string; metadata?: string | null }): Promise<Organization | undefined> {
+      await db.update(organizations).set({ ...data, updatedAt: Date.now() }).where(eq(organizations.id, id))
+      const rows = await db.select().from(organizations).where(eq(organizations.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async patchMetadata(id: string, patch: Record<string, unknown>): Promise<Organization | undefined> {
+      const rows = await db.select().from(organizations).where(eq(organizations.id, id)).limit(1)
+      const org  = rows[0]
+      if (!org) return undefined
+
+      const current: Record<string, unknown> = 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(organizations).set({ metadata: JSON.stringify(merged), updatedAt: Date.now() }).where(eq(organizations.id, id))
+      const updated = await db.select().from(organizations).where(eq(organizations.id, id)).limit(1)
+      return updated[0]
+    },
+
+    async delete(id: string): Promise<void> {
+      await db.delete(organizations).where(eq(organizations.id, id))
+    },
+
+    async listAll(): Promise<Organization[]> {
+      return db.select().from(organizations).orderBy(desc(organizations.createdAt))
+    },
+
+    async hardDelete(id: string): Promise<void> {
+      await db.delete(organizations).where(eq(organizations.id, id))
+    },
+  }
+}
+
+export type OrganizationRepo = ReturnType<typeof createOrganizationRepo>

package/src/repo/projects.ts

@@ -0,0 +1,106 @@
+import { and, eq } from 'drizzle-orm'
+import { generateId, generateShortId, generateSlug } from '@baseworks/core'
+import type { Project } from '../types.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDB = any
+
+async function resolveSlug(db: AnyDB, projectsTable: any, workspaceId: string, base: string): Promise<string> {
+  let slug = base
+  let i    = 2
+  while (true) {
+    const rows = await db
+      .select({ id: projectsTable.id })
+      .from(projectsTable)
+      .where(and(eq(projectsTable.workspaceId, workspaceId), eq(projectsTable.slug, slug)))
+      .limit(1)
+    if (rows.length === 0) return slug
+    slug = `${base}-${i++}`
+  }
+}
+
+export function createProjectRepo(db: AnyDB, schema: { projects: any }) {
+  const { projects } = schema
+
+  return {
+    async create(data: { workspaceId: string; name: string; slug?: string; isDefault?: boolean; id?: string }): Promise<Project> {
+      const now  = Date.now()
+      const base = data.slug ?? generateSlug(data.name)
+      const slug = await resolveSlug(db, projects, data.workspaceId, base)
+      const row  = {
+        id:          data.id ?? generateId(),
+        workspaceId: data.workspaceId,
+        shortId:     generateShortId(),
+        slug,
+        name:        data.name,
+        isDefault:   data.isDefault ?? false,
+        metadata:    null,
+        createdAt:   now,
+        updatedAt:   now,
+      }
+      await db.insert(projects).values(row)
+      return row
+    },
+
+    async findById(id: string): Promise<Project | undefined> {
+      const rows = await db.select().from(projects).where(eq(projects.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async findByShortId(shortId: string): Promise<Project | undefined> {
+      const rows = await db.select().from(projects).where(eq(projects.shortId, shortId)).limit(1)
+      return rows[0]
+    },
+
+    async findBySlug(workspaceId: string, slug: string): Promise<Project | undefined> {
+      const rows = await db.select().from(projects).where(and(eq(projects.workspaceId, workspaceId), eq(projects.slug, slug))).limit(1)
+      return rows[0]
+    },
+
+    async findByRef(workspaceId: string, ref: string): Promise<Project | undefined> {
+      const bySlug = await db.select().from(projects).where(and(eq(projects.workspaceId, workspaceId), eq(projects.slug, ref))).limit(1)
+      if (bySlug[0]) return bySlug[0]
+      const byShortId = await db.select().from(projects).where(and(eq(projects.workspaceId, workspaceId), eq(projects.shortId, ref))).limit(1)
+      return byShortId[0]
+    },
+
+    async listByWorkspace(workspaceId: string): Promise<Project[]> {
+      return db.select().from(projects).where(eq(projects.workspaceId, workspaceId))
+    },
+
+    async findDefault(workspaceId: string): Promise<Project | undefined> {
+      const rows = await db.select().from(projects).where(and(eq(projects.workspaceId, workspaceId), eq(projects.isDefault, true))).limit(1)
+      return rows[0]
+    },
+
+    async update(id: string, data: { name?: string }): Promise<Project | undefined> {
+      await db.update(projects).set({ ...data, updatedAt: Date.now() }).where(eq(projects.id, id))
+      const rows = await db.select().from(projects).where(eq(projects.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async delete(id: string): Promise<void> {
+      await db.delete(projects).where(eq(projects.id, id))
+    },
+
+    async getMetadata(id: string): Promise<Record<string, unknown>> {
+      const rows = await db.select({ metadata: projects.metadata }).from(projects).where(eq(projects.id, id)).limit(1)
+      const row  = rows[0]
+      if (!row?.metadata) return {}
+      try { return JSON.parse(row.metadata) as Record<string, unknown> } catch { return {} }
+    },
+
+    async patchMetadata(id: string, patch: Record<string, unknown>): Promise<Record<string, unknown>> {
+      const existing = await this.getMetadata(id)
+      const next: Record<string, unknown> = { ...existing }
+      for (const [k, v] of Object.entries(patch)) {
+        if (v === null) delete next[k]
+        else next[k] = v
+      }
+      await db.update(projects).set({ metadata: JSON.stringify(next), updatedAt: Date.now() }).where(eq(projects.id, id))
+      return next
+    },
+  }
+}
+
+export type ProjectRepo = ReturnType<typeof createProjectRepo>

package/src/repo/workspaces.ts

@@ -0,0 +1,87 @@
+import { and, eq } from 'drizzle-orm'
+import { generateId, generateShortId, generateSlug } from '@baseworks/core'
+import type { Workspace } from '../types.js'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyDB = any
+
+async function resolveSlug(db: AnyDB, workspacesTable: any, organizationId: string, base: string): Promise<string> {
+  let slug = base
+  let i    = 2
+  while (true) {
+    const rows = await db
+      .select({ id: workspacesTable.id })
+      .from(workspacesTable)
+      .where(and(eq(workspacesTable.organizationId, organizationId), eq(workspacesTable.slug, slug)))
+      .limit(1)
+    if (rows.length === 0) return slug
+    slug = `${base}-${i++}`
+  }
+}
+
+export function createWorkspaceRepo(db: AnyDB, schema: { workspaces: any }) {
+  const { workspaces } = schema
+
+  return {
+    async create(data: { organizationId: string; name: string; slug?: string; isDefault?: boolean; id?: string }): Promise<Workspace> {
+      const now  = Date.now()
+      const base = data.slug ?? generateSlug(data.name)
+      const slug = await resolveSlug(db, workspaces, data.organizationId, base)
+      const row  = {
+        id:             data.id ?? generateId(),
+        organizationId: data.organizationId,
+        shortId:        generateShortId(),
+        slug,
+        name:           data.name,
+        isDefault:      data.isDefault ?? false,
+        createdAt:      now,
+        updatedAt:      now,
+      }
+      await db.insert(workspaces).values(row)
+      return row
+    },
+
+    async findById(id: string): Promise<Workspace | undefined> {
+      const rows = await db.select().from(workspaces).where(eq(workspaces.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async findByShortId(shortId: string): Promise<Workspace | undefined> {
+      const rows = await db.select().from(workspaces).where(eq(workspaces.shortId, shortId)).limit(1)
+      return rows[0]
+    },
+
+    async findBySlug(organizationId: string, slug: string): Promise<Workspace | undefined> {
+      const rows = await db.select().from(workspaces).where(and(eq(workspaces.organizationId, organizationId), eq(workspaces.slug, slug))).limit(1)
+      return rows[0]
+    },
+
+    async findByRef(organizationId: string, ref: string): Promise<Workspace | undefined> {
+      const bySlug = await db.select().from(workspaces).where(and(eq(workspaces.organizationId, organizationId), eq(workspaces.slug, ref))).limit(1)
+      if (bySlug[0]) return bySlug[0]
+      const byShortId = await db.select().from(workspaces).where(and(eq(workspaces.organizationId, organizationId), eq(workspaces.shortId, ref))).limit(1)
+      return byShortId[0]
+    },
+
+    async listByOrg(organizationId: string): Promise<Workspace[]> {
+      return db.select().from(workspaces).where(eq(workspaces.organizationId, organizationId))
+    },
+
+    async findDefault(organizationId: string): Promise<Workspace | undefined> {
+      const rows = await db.select().from(workspaces).where(and(eq(workspaces.organizationId, organizationId), eq(workspaces.isDefault, true))).limit(1)
+      return rows[0]
+    },
+
+    async update(id: string, data: { name?: string }): Promise<Workspace | undefined> {
+      await db.update(workspaces).set({ ...data, updatedAt: Date.now() }).where(eq(workspaces.id, id))
+      const rows = await db.select().from(workspaces).where(eq(workspaces.id, id)).limit(1)
+      return rows[0]
+    },
+
+    async delete(id: string): Promise<void> {
+      await db.delete(workspaces).where(eq(workspaces.id, id))
+    },
+  }
+}
+
+export type WorkspaceRepo = ReturnType<typeof createWorkspaceRepo>

package/src/schema/environments.ts

@@ -0,0 +1,14 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { projects } from './projects';
+
+export const environments = sqliteTable('environments', {
+  id:        text('id').primaryKey(),
+  projectId: text('project_id').notNull().references(() => projects.id, { onDelete: 'cascade' }),
+  shortId:   text('short_id').notNull().unique(),
+  slug:      text('slug').notNull(),
+  name:      text('name').notNull(),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+}, (t) => ({
+  projectSlugUniq: uniqueIndex('environments_project_slug_uniq').on(t.projectId, t.slug),
+}));

package/src/schema/index.ts

@@ -0,0 +1,5 @@
+// Default export: SQLite (backward compat for existing D1/Turso projects)
+export { organizations } from './sqlite/organizations.js'
+export { workspaces }    from './sqlite/workspaces.js'
+export { projects }      from './sqlite/projects.js'
+export { environments }  from './sqlite/environments.js'

package/src/schema/organizations.ts

@@ -0,0 +1,11 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const organizations = sqliteTable('organizations', {
+  id:        text('id').primaryKey(),
+  shortId:   text('short_id').notNull().unique(),
+  slug:      text('slug').notNull().unique(),
+  name:      text('name').notNull(),
+  metadata:  text('metadata'),   // JSON: { logo_url, website, ... }
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/schema/pg/environments.ts

@@ -0,0 +1,14 @@
+import { bigint, pgTable, text, uniqueIndex } from 'drizzle-orm/pg-core'
+import { projects } from './projects.js'
+
+export const environments = pgTable('environments', {
+  id:        text('id').primaryKey(),
+  projectId: text('project_id').notNull().references(() => projects.id, { onDelete: 'cascade' }),
+  shortId:   text('short_id').notNull().unique(),
+  slug:      text('slug').notNull(),
+  name:      text('name').notNull(),
+  createdAt: bigint('created_at', { mode: 'number' }).notNull(),
+  updatedAt: bigint('updated_at', { mode: 'number' }).notNull(),
+}, (t) => [
+  uniqueIndex('environments_project_slug_uniq').on(t.projectId, t.slug),
+])

package/src/schema/pg/index.ts

@@ -0,0 +1,4 @@
+export { organizations } from './organizations.js'
+export { workspaces }   from './workspaces.js'
+export { projects }     from './projects.js'
+export { environments } from './environments.js'

package/src/schema/pg/organizations.ts

@@ -0,0 +1,11 @@
+import { bigint, pgTable, text } from 'drizzle-orm/pg-core'
+
+export const organizations = pgTable('organizations', {
+  id:        text('id').primaryKey(),
+  shortId:   text('short_id').notNull().unique(),
+  slug:      text('slug').notNull().unique(),
+  name:      text('name').notNull(),
+  metadata:  text('metadata'),
+  createdAt: bigint('created_at', { mode: 'number' }).notNull(),
+  updatedAt: bigint('updated_at', { mode: 'number' }).notNull(),
+})

package/src/schema/pg/projects.ts

@@ -0,0 +1,16 @@
+import { bigint, boolean, pgTable, text, uniqueIndex } from 'drizzle-orm/pg-core'
+import { workspaces } from './workspaces.js'
+
+export const projects = pgTable('projects', {
+  id:          text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull().references(() => workspaces.id, { onDelete: 'cascade' }),
+  shortId:     text('short_id').notNull().unique(),
+  slug:        text('slug').notNull(),
+  name:        text('name').notNull(),
+  isDefault:   boolean('is_default').notNull().default(false),
+  metadata:    text('metadata'),
+  createdAt:   bigint('created_at', { mode: 'number' }).notNull(),
+  updatedAt:   bigint('updated_at', { mode: 'number' }).notNull(),
+}, (t) => [
+  uniqueIndex('projects_workspace_slug_uniq').on(t.workspaceId, t.slug),
+])

package/src/schema/pg/workspaces.ts

@@ -0,0 +1,15 @@
+import { bigint, boolean, pgTable, text, uniqueIndex } from 'drizzle-orm/pg-core'
+import { organizations } from './organizations.js'
+
+export const workspaces = pgTable('workspaces', {
+  id:             text('id').primaryKey(),
+  organizationId: text('organization_id').notNull().references(() => organizations.id, { onDelete: 'cascade' }),
+  shortId:        text('short_id').notNull().unique(),
+  slug:           text('slug').notNull(),
+  name:           text('name').notNull(),
+  isDefault:      boolean('is_default').notNull().default(false),
+  createdAt:      bigint('created_at', { mode: 'number' }).notNull(),
+  updatedAt:      bigint('updated_at', { mode: 'number' }).notNull(),
+}, (t) => [
+  uniqueIndex('workspaces_org_slug_uniq').on(t.organizationId, t.slug),
+])

package/src/schema/projects.ts

@@ -0,0 +1,16 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { workspaces } from './workspaces';
+
+export const projects = sqliteTable('projects', {
+  id:          text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull().references(() => workspaces.id, { onDelete: 'cascade' }),
+  shortId:     text('short_id').notNull().unique(),
+  slug:        text('slug').notNull(),
+  name:        text('name').notNull(),
+  isDefault:   integer('is_default', { mode: 'boolean' }).notNull().default(false),
+  metadata:    text('metadata'),
+  createdAt:   integer('created_at').notNull(),
+  updatedAt:   integer('updated_at').notNull(),
+}, (t) => ({
+  workspaceSlugUniq: uniqueIndex('projects_workspace_slug_uniq').on(t.workspaceId, t.slug),
+}));

package/src/schema/sqlite/environments.ts

@@ -0,0 +1,14 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { projects } from './projects.js';
+
+export const environments = sqliteTable('environments', {
+  id:        text('id').primaryKey(),
+  projectId: text('project_id').notNull().references(() => projects.id, { onDelete: 'cascade' }),
+  shortId:   text('short_id').notNull().unique(),
+  slug:      text('slug').notNull(),
+  name:      text('name').notNull(),
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+}, (t) => ({
+  projectSlugUniq: uniqueIndex('environments_project_slug_uniq').on(t.projectId, t.slug),
+}));

package/src/schema/sqlite/index.ts

@@ -0,0 +1,4 @@
+export { organizations } from './organizations.js'
+export { workspaces }   from './workspaces.js'
+export { projects }     from './projects.js'
+export { environments } from './environments.js'

package/src/schema/sqlite/organizations.ts

@@ -0,0 +1,11 @@
+import { integer, sqliteTable, text } from 'drizzle-orm/sqlite-core';
+
+export const organizations = sqliteTable('organizations', {
+  id:        text('id').primaryKey(),
+  shortId:   text('short_id').notNull().unique(),
+  slug:      text('slug').notNull().unique(),
+  name:      text('name').notNull(),
+  metadata:  text('metadata'),   // JSON: { logo_url, website, ... }
+  createdAt: integer('created_at').notNull(),
+  updatedAt: integer('updated_at').notNull(),
+});

package/src/schema/sqlite/projects.ts

@@ -0,0 +1,16 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { workspaces } from './workspaces.js';
+
+export const projects = sqliteTable('projects', {
+  id:          text('id').primaryKey(),
+  workspaceId: text('workspace_id').notNull().references(() => workspaces.id, { onDelete: 'cascade' }),
+  shortId:     text('short_id').notNull().unique(),
+  slug:        text('slug').notNull(),
+  name:        text('name').notNull(),
+  isDefault:   integer('is_default', { mode: 'boolean' }).notNull().default(false),
+  metadata:    text('metadata'),
+  createdAt:   integer('created_at').notNull(),
+  updatedAt:   integer('updated_at').notNull(),
+}, (t) => ({
+  workspaceSlugUniq: uniqueIndex('projects_workspace_slug_uniq').on(t.workspaceId, t.slug),
+}));

package/src/schema/sqlite/workspaces.ts

@@ -0,0 +1,15 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organizations } from './organizations.js';
+
+export const workspaces = sqliteTable('workspaces', {
+  id:             text('id').primaryKey(),
+  organizationId: text('organization_id').notNull().references(() => organizations.id, { onDelete: 'cascade' }),
+  shortId:        text('short_id').notNull().unique(),
+  slug:           text('slug').notNull(),
+  name:           text('name').notNull(),
+  isDefault:      integer('is_default', { mode: 'boolean' }).notNull().default(false),
+  createdAt:      integer('created_at').notNull(),
+  updatedAt:      integer('updated_at').notNull(),
+}, (t) => ({
+  orgSlugUniq: uniqueIndex('workspaces_org_slug_uniq').on(t.organizationId, t.slug),
+}));

package/src/schema/workspaces.ts

@@ -0,0 +1,15 @@
+import { integer, sqliteTable, text, uniqueIndex } from 'drizzle-orm/sqlite-core';
+import { organizations } from './organizations';
+
+export const workspaces = sqliteTable('workspaces', {
+  id:             text('id').primaryKey(),
+  organizationId: text('organization_id').notNull().references(() => organizations.id, { onDelete: 'cascade' }),
+  shortId:        text('short_id').notNull().unique(),
+  slug:           text('slug').notNull(),
+  name:           text('name').notNull(),
+  isDefault:      integer('is_default', { mode: 'boolean' }).notNull().default(false),
+  createdAt:      integer('created_at').notNull(),
+  updatedAt:      integer('updated_at').notNull(),
+}, (t) => ({
+  orgSlugUniq: uniqueIndex('workspaces_org_slug_uniq').on(t.organizationId, t.slug),
+}));