@maestro-js/agent-skills 1.0.0-alpha.2 → 1.0.0-alpha.21

package/skills/maestro-examples/references/cadence/packages/services/src/organization/organization-db-provider.test.ts

@@ -0,0 +1,53 @@
+import { test } from 'beartest-js'
+import { expect } from 'expect'
+import { organizationDbProvider } from './organization-db-provider.ts'
+
+const createdIds: number[] = []
+
+test.afterEach(async () => {
+  for (const id of createdIds) {
+    await organizationDbProvider.hardDelete(id)
+  }
+  createdIds.length = 0
+})
+
+test('create and getById', async () => {
+  const id = await organizationDbProvider.create({ name: 'Acme Corp', slug: 'acme-corp' })
+  createdIds.push(id)
+
+  const org = await organizationDbProvider.getById(id)
+  expect(org).not.toBeNull()
+  expect(org!.name).toBe('Acme Corp')
+  expect(org!.slug).toBe('acme-corp')
+  expect(org!.deletedDate).toBeNull()
+})
+
+test('getBySlug', async () => {
+  const id = await organizationDbProvider.create({ name: 'Slug Test', slug: 'slug-test' })
+  createdIds.push(id)
+
+  const org = await organizationDbProvider.getBySlug('slug-test')
+  expect(org).not.toBeNull()
+  expect(org!.id).toBe(id)
+  expect(org!.name).toBe('Slug Test')
+})
+
+test('update', async () => {
+  const id = await organizationDbProvider.create({ name: 'Old Name', slug: 'update-test' })
+  createdIds.push(id)
+
+  await organizationDbProvider.update(id, { name: 'New Name' })
+
+  const org = await organizationDbProvider.getById(id)
+  expect(org!.name).toBe('New Name')
+})
+
+test('softDelete', async () => {
+  const id = await organizationDbProvider.create({ name: 'To Delete', slug: 'delete-test' })
+  createdIds.push(id)
+
+  await organizationDbProvider.softDelete(id)
+
+  const org = await organizationDbProvider.getById(id)
+  expect(org).toBeNull()
+})

package/skills/maestro-examples/references/cadence/packages/services/src/organization/organization-db-provider.ts

@@ -0,0 +1,60 @@
+import { Db } from '@maestro-js/db'
+import { OrganizationSchemas } from '@cadence/schemas'
+import { instantFns } from 'iso-fns'
+
+type Organization = OrganizationSchemas.organizationModel
+
+async function create(data: Pick<Organization, 'name' | 'slug'>): Promise<number> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  const result = await Db.insert(
+    'INSERT INTO organizations (name, slug, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?)',
+    [data.name, data.slug, now, now]
+  )
+  return result.insertId
+}
+
+async function getById(id: number): Promise<Organization | null> {
+  const rows = await Db.select('SELECT * FROM organizations WHERE id = ? AND deletedDate IS NULL', [id])
+  const row = rows[0]
+  if (!row) return null
+  return OrganizationSchemas.organizationModel.parse(row)
+}
+
+async function getBySlug(slug: string): Promise<Organization | null> {
+  const rows = await Db.select('SELECT * FROM organizations WHERE slug = ? AND deletedDate IS NULL', [slug])
+  const row = rows[0]
+  if (!row) return null
+  return OrganizationSchemas.organizationModel.parse(row)
+}
+
+async function update(id: number, data: Pick<Organization, 'name'>): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.update('UPDATE organizations SET name = ?, lastModifiedDate = ? WHERE id = ?', [data.name, now, id])
+}
+
+async function softDelete(id: number): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.update('UPDATE organizations SET deletedDate = ?, lastModifiedDate = ? WHERE id = ?', [now, now, id])
+}
+
+async function seedCreate(data: Organization): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.insert(
+    'INSERT INTO organizations (id, name, slug, deletedDate, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?)',
+    [data.id, data.name, data.slug, data.deletedDate ?? null, now, now]
+  )
+}
+
+async function hardDelete(id: number): Promise<void> {
+  await Db.delete('DELETE FROM organizations WHERE id = ?', [id])
+}
+
+export const organizationDbProvider = {
+  create,
+  getById,
+  getBySlug,
+  update,
+  softDelete,
+  seedCreate,
+  hardDelete
+}

package/skills/maestro-examples/references/cadence/packages/services/src/organization/organization-use-cases.ts

@@ -0,0 +1,88 @@
+import z from 'zod'
+import { Db } from '@maestro-js/db'
+import { Hash } from '@maestro-js/hash'
+import { Log } from '@maestro-js/log'
+import { Permissions } from '@maestro-js/permissions'
+import { OrganizationSchemas, UserSchemas } from '@cadence/schemas'
+import { organizationDbProvider } from './organization-db-provider.ts'
+import { userDbProvider } from '../user/user-db-provider.ts'
+
+const log = Log.channel('organization')
+
+const Profile = UserSchemas.profileModel
+
+// ─── Create Organization ──────────────────────────────────────────────────────
+
+export const CreateOrganization = z
+  .function({
+    input: [
+      OrganizationSchemas.createOrganizationForm.extend({
+        adminName: z.string().min(1),
+        adminEmail: z.string().email(),
+        adminPassword: z.string().min(8)
+      })
+    ]
+  })
+  .implement(async ({ name, slug, adminName, adminEmail, adminPassword }) => {
+    const passwordHash = await Hash.provider('bcrypt').hash(adminPassword)
+
+    let orgId!: number
+
+    await Db.transaction(async () => {
+      orgId = await organizationDbProvider.create({ name, slug })
+
+      await userDbProvider.create({
+        organizationId: orgId,
+        name: adminName,
+        email: adminEmail.toLowerCase().trim(),
+        passwordHash,
+        role: 'admin'
+      })
+    })
+
+    log.info('Organization created', { action: 'organization.create', orgId })
+
+    return { orgId }
+  })
+
+// ─── View Organization ────────────────────────────────────────────────────────
+
+export const ViewOrganization = z
+  .function({
+    input: [z.object({}), Profile]
+  })
+  .implement(async (_data, profile) => {
+    Permissions.gate(profile, 'organization', 'read')
+
+    const organization = await organizationDbProvider.getById(profile.organizationId)
+
+    return organization
+  })
+
+// ─── Edit Organization ────────────────────────────────────────────────────────
+
+export const EditOrganization = z
+  .function({
+    input: [OrganizationSchemas.editOrganizationForm, Profile]
+  })
+  .implement(async ({ name }, profile) => {
+    Permissions.gate(profile, 'organization', 'update')
+
+    await organizationDbProvider.update(profile.organizationId, { name })
+
+    log.info('Organization edited', { action: 'organization.edit', orgId: profile.organizationId })
+  })
+
+// ─── Delete Organization ──────────────────────────────────────────────────────
+
+export const DeleteOrganization = z
+  .function({
+    input: [z.object({}), Profile]
+  })
+  .implement(async (_data, profile) => {
+    Permissions.gate(profile, 'organization', 'delete')
+
+    await organizationDbProvider.softDelete(profile.organizationId)
+
+    log.info('Organization deleted', { action: 'organization.delete', orgId: profile.organizationId })
+  })

package/skills/maestro-examples/references/cadence/packages/services/src/permissions.ts

@@ -0,0 +1,28 @@
+import { Permissions } from '@maestro-js/permissions'
+import type { UserSchemas } from '@cadence/schemas'
+
+export type ActionMap = {
+  organization: ['read', 'update', 'delete']
+  user: ['list', 'invite', 'changeRole', 'remove']
+  contact: ['list', 'read', 'create', 'update', 'archive', 'restore', 'delete']
+  interaction: ['list', 'create', 'update', 'delete']
+}
+
+export const permissionsDriver = Permissions.drivers.static<ActionMap, UserSchemas.profileModel | null>((profile, allow) => {
+  if (!profile) return
+
+  allow('organization', ['read'])
+  allow('user', ['list'])
+  allow('contact', ['list', 'read'])
+  allow('interaction', ['list'])
+
+  if (profile.role === 'member' || profile.role === 'admin') {
+    allow('contact', ['create', 'update', 'archive', 'restore', 'delete'])
+    allow('interaction', ['create', 'update', 'delete'])
+  }
+
+  if (profile.role === 'admin') {
+    allow('organization', ['update', 'delete'])
+    allow('user', ['invite', 'changeRole', 'remove'])
+  }
+})

package/skills/maestro-examples/references/cadence/packages/services/src/testing/contact-seed.ts

@@ -0,0 +1,30 @@
+import type { ContactSchemas } from '@cadence/schemas'
+import { instantFns } from 'iso-fns'
+import { contactDbProvider } from '../contact/contact-db-provider.ts'
+
+export function ContactSeed(contact: Partial<ContactSchemas.contactModel> & { id: number; organizationId: number }) {
+  const mock: Omit<ContactSchemas.contactModel, 'id' | 'organizationId'> = {
+    firstName: 'Test',
+    lastName: 'Contact',
+    email: `test-contact-${contact.id}@example.com`,
+    phone: null,
+    jobTitle: null,
+    tags: [],
+    archivedDate: null,
+    deletedDate: null,
+    createdDate: instantFns.now(),
+    lastModifiedDate: instantFns.now()
+  }
+  const merged = { ...mock, ...contact }
+
+  async function setup() {
+    await teardown()
+    await contactDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await contactDbProvider.hardDelete(merged.id)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/cadence/packages/services/src/testing/index.ts

@@ -0,0 +1,13 @@
+import { ContactSeed } from './contact-seed.ts'
+import { InteractionSeed } from './interaction-seed.ts'
+import { OrganizationSeed } from './organization-seed.ts'
+import { SeedPipe } from './seed-pipe.ts'
+import { UserSeed } from './user-seed.ts'
+
+export const H = {
+  ContactSeed,
+  InteractionSeed,
+  OrganizationSeed,
+  SeedPipe,
+  UserSeed
+}

package/skills/maestro-examples/references/cadence/packages/services/src/testing/interaction-seed.ts

@@ -0,0 +1,29 @@
+import type { InteractionSchemas } from '@cadence/schemas'
+import { instantFns } from 'iso-fns'
+import { interactionDbProvider } from '../interaction/interaction-db-provider.ts'
+
+export function InteractionSeed(
+  interaction: Partial<InteractionSchemas.interactionModel> & { id: number; contactId: number; userId: number }
+) {
+  const mock: Omit<InteractionSchemas.interactionModel, 'id' | 'contactId' | 'userId'> = {
+    type: 'note',
+    subject: null,
+    body: 'Test interaction body',
+    date: instantFns.now(),
+    deletedDate: null,
+    createdDate: instantFns.now(),
+    lastModifiedDate: instantFns.now()
+  }
+  const merged = { ...mock, ...interaction }
+
+  async function setup() {
+    await teardown()
+    await interactionDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await interactionDbProvider.hardDelete(merged.id)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/cadence/packages/services/src/testing/organization-seed.ts

@@ -0,0 +1,25 @@
+import type { OrganizationSchemas } from '@cadence/schemas'
+import { instantFns } from 'iso-fns'
+import { organizationDbProvider } from '../organization/organization-db-provider.ts'
+
+export function OrganizationSeed(org: Partial<OrganizationSchemas.organizationModel> & { id: number }) {
+  const mock: Omit<OrganizationSchemas.organizationModel, 'id'> = {
+    name: `Test Org ${org.id}`,
+    slug: `test-org-${org.id}`,
+    deletedDate: null,
+    createdDate: instantFns.now(),
+    lastModifiedDate: instantFns.now()
+  }
+  const merged = { ...mock, ...org }
+
+  async function setup() {
+    await teardown()
+    await organizationDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await organizationDbProvider.hardDelete(merged.id)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/cadence/packages/services/src/testing/seed-pipe.ts

@@ -0,0 +1,38 @@
+export type SeedFn = { setup(): Promise<void>; teardown: () => Promise<void> }
+
+export function SeedPipe(...seeds: SeedFn[]): SeedFn {
+  const seedFnMap = new Map<() => Promise<SeedFn>, Promise<SeedFn>>()
+
+  function resolveSeeder(seeder: SeedFn | (() => Promise<SeedFn>)): Promise<SeedFn> {
+    if (typeof seeder === 'function') {
+      const existing = seedFnMap.get(seeder)
+      if (existing) {
+        return existing
+      } else {
+        seedFnMap.set(seeder, seeder())
+        return seedFnMap.get(seeder)!
+      }
+    } else {
+      return Promise.resolve(seeder)
+    }
+  }
+
+  async function setup() {
+    for (const seed of seeds) {
+      const seeder = await resolveSeeder(seed)
+      await seeder.setup()
+    }
+  }
+
+  async function teardown() {
+    const seedsReversed = [...seeds].reverse()
+    for (const seed of seedsReversed) {
+      const seeder = await resolveSeeder(seed)
+      await seeder.teardown()
+    }
+  }
+  return {
+    setup,
+    teardown
+  }
+}

package/skills/maestro-examples/references/cadence/packages/services/src/testing/user-seed.ts

@@ -0,0 +1,27 @@
+import type { UserSchemas } from '@cadence/schemas'
+import { instantFns } from 'iso-fns'
+import { userDbProvider } from '../user/user-db-provider.ts'
+
+export function UserSeed(user: Partial<UserSchemas.userModel> & { id: number; organizationId: number }) {
+  const mock: Omit<UserSchemas.userModel, 'id' | 'organizationId'> = {
+    name: `Test User ${user.id}`,
+    email: `test-${user.id}@example.com`,
+    passwordHash: '$2b$12$INJ2/8QWIwTkmpLWQ1wMmeBPVvDpZstXucYx355vjdonr1nBAuj8a',
+    role: 'admin',
+    deletedDate: null,
+    createdDate: instantFns.now(),
+    lastModifiedDate: instantFns.now()
+  }
+  const merged = { ...mock, ...user }
+
+  async function setup() {
+    await teardown()
+    await userDbProvider.seedCreate(merged)
+  }
+
+  async function teardown() {
+    await userDbProvider.hardDelete(merged.id)
+  }
+
+  return { setup, teardown }
+}

package/skills/maestro-examples/references/cadence/packages/services/src/user/index.ts

@@ -0,0 +1,27 @@
+import {
+  InviteUser,
+  ListUsers,
+  ChangeUserRole,
+  RemoveUser,
+  EmailAlreadyInUseError,
+  UserNotFoundError,
+  CannotChangeOwnRoleError,
+  CannotRemoveSelfError,
+  CannotDemoteLastAdminError,
+  CannotRemoveLastAdminError
+} from './user-use-cases.ts'
+
+export const UserService = {
+  InviteUser,
+  ListUsers,
+  ChangeUserRole,
+  RemoveUser,
+  errors: {
+    EmailAlreadyInUseError,
+    UserNotFoundError,
+    CannotChangeOwnRoleError,
+    CannotRemoveSelfError,
+    CannotDemoteLastAdminError,
+    CannotRemoveLastAdminError
+  }
+}

package/skills/maestro-examples/references/cadence/packages/services/src/user/user-db-provider.test.ts

@@ -0,0 +1,100 @@
+import { test } from 'beartest-js'
+import { expect } from 'expect'
+import { H } from '../testing/index.ts'
+import { userDbProvider } from './user-db-provider.ts'
+
+const org = H.OrganizationSeed({ id: 1 })
+const pipe = H.SeedPipe(org)
+
+test.beforeEach(async () => { await pipe.setup() })
+test.afterEach(async () => { await pipe.teardown() })
+
+const createdIds: number[] = []
+test.afterEach(async () => {
+  for (const id of createdIds) {
+    await userDbProvider.hardDelete(id)
+  }
+  createdIds.length = 0
+})
+
+test('create and getById', async () => {
+  const id = await userDbProvider.create({
+    organizationId: 1,
+    name: 'Jane Doe',
+    email: 'jane@example.com',
+    passwordHash: '$2b$12$INJ2/8QWIwTkmpLWQ1wMmeBPVvDpZstXucYx355vjdonr1nBAuj8a',
+    role: 'admin'
+  })
+  createdIds.push(id)
+
+  const user = await userDbProvider.getById(id)
+  expect(user).not.toBeNull()
+  expect(user!.name).toBe('Jane Doe')
+  expect(user!.email).toBe('jane@example.com')
+  expect(user!.organizationId).toBe(1)
+  expect(user!.role).toBe('admin')
+  expect(user!.deletedDate).toBeNull()
+})
+
+test('getByEmailAndOrgId', async () => {
+  const id = await userDbProvider.create({
+    organizationId: 1,
+    name: 'Bob',
+    email: 'bob@example.com',
+    passwordHash: '$2b$12$INJ2/8QWIwTkmpLWQ1wMmeBPVvDpZstXucYx355vjdonr1nBAuj8a',
+    role: 'member'
+  })
+  createdIds.push(id)
+
+  const user = await userDbProvider.getByEmailAndOrgId('bob@example.com', 1)
+  expect(user).not.toBeNull()
+  expect(user!.id).toBe(id)
+  expect(user!.name).toBe('Bob')
+})
+
+test('listByOrganizationId', async () => {
+  const id = await userDbProvider.create({
+    organizationId: 1,
+    name: 'List User',
+    email: 'list@example.com',
+    passwordHash: '$2b$12$INJ2/8QWIwTkmpLWQ1wMmeBPVvDpZstXucYx355vjdonr1nBAuj8a',
+    role: 'member'
+  })
+  createdIds.push(id)
+
+  const users = await userDbProvider.listByOrganizationId(1)
+  expect(users.length).toBeGreaterThanOrEqual(1)
+  expect(users.some((u) => u.id === id)).toBe(true)
+})
+
+test('updateRole', async () => {
+  const id = await userDbProvider.create({
+    organizationId: 1,
+    name: 'Role User',
+    email: 'role@example.com',
+    passwordHash: '$2b$12$INJ2/8QWIwTkmpLWQ1wMmeBPVvDpZstXucYx355vjdonr1nBAuj8a',
+    role: 'member'
+  })
+  createdIds.push(id)
+
+  await userDbProvider.updateRole(id, 'admin')
+
+  const user = await userDbProvider.getById(id)
+  expect(user!.role).toBe('admin')
+})
+
+test('softDelete', async () => {
+  const id = await userDbProvider.create({
+    organizationId: 1,
+    name: 'Delete Me',
+    email: 'delete@example.com',
+    passwordHash: '$2b$12$INJ2/8QWIwTkmpLWQ1wMmeBPVvDpZstXucYx355vjdonr1nBAuj8a',
+    role: 'member'
+  })
+  createdIds.push(id)
+
+  await userDbProvider.softDelete(id)
+
+  const user = await userDbProvider.getById(id)
+  expect(user).toBeNull()
+})

package/skills/maestro-examples/references/cadence/packages/services/src/user/user-db-provider.ts

@@ -0,0 +1,69 @@
+import { Db } from '@maestro-js/db'
+import { UserSchemas } from '@cadence/schemas'
+import { instantFns } from 'iso-fns'
+
+type User = UserSchemas.userModel
+
+async function create(data: Pick<User, 'organizationId' | 'name' | 'email' | 'passwordHash' | 'role'>): Promise<number> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  const result = await Db.insert(
+    'INSERT INTO users (organizationId, name, email, passwordHash, role, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?, ?)',
+    [data.organizationId, data.name, data.email, data.passwordHash, data.role, now, now]
+  )
+  return result.insertId
+}
+
+async function getById(id: number): Promise<User | null> {
+  const rows = await Db.select('SELECT * FROM users WHERE id = ? AND deletedDate IS NULL', [id])
+  const row = rows[0]
+  if (!row) return null
+  return UserSchemas.userModel.parse(row)
+}
+
+async function getByEmailAndOrgId(email: string, orgId: number): Promise<User | null> {
+  const rows = await Db.select('SELECT * FROM users WHERE email = ? AND organizationId = ? AND deletedDate IS NULL', [
+    email,
+    orgId
+  ])
+  const row = rows[0]
+  if (!row) return null
+  return UserSchemas.userModel.parse(row)
+}
+
+async function listByOrganizationId(orgId: number): Promise<User[]> {
+  const rows = await Db.select('SELECT * FROM users WHERE organizationId = ? AND deletedDate IS NULL', [orgId])
+  return rows.map((row) => UserSchemas.userModel.parse(row))
+}
+
+async function updateRole(id: number, role: User['role']): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.update('UPDATE users SET role = ?, lastModifiedDate = ? WHERE id = ?', [role, now, id])
+}
+
+async function softDelete(id: number): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.update('UPDATE users SET deletedDate = ?, lastModifiedDate = ? WHERE id = ?', [now, now, id])
+}
+
+async function seedCreate(data: User): Promise<void> {
+  const now = instantFns.formatISO9075(instantFns.now())
+  await Db.insert(
+    'INSERT INTO users (id, organizationId, name, email, passwordHash, role, deletedDate, createdDate, lastModifiedDate) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)',
+    [data.id, data.organizationId, data.name, data.email, data.passwordHash, data.role, data.deletedDate ?? null, now, now]
+  )
+}
+
+async function hardDelete(id: number): Promise<void> {
+  await Db.delete('DELETE FROM users WHERE id = ?', [id])
+}
+
+export const userDbProvider = {
+  create,
+  getById,
+  getByEmailAndOrgId,
+  listByOrganizationId,
+  updateRole,
+  softDelete,
+  seedCreate,
+  hardDelete
+}