@astrale-os/cli 0.8.1-alpha.6 → 1.0.0-beta.0

package/studio/server/introspect/overlay-tsmorph.test.ts

@@ -3,7 +3,7 @@ import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
-import { buildHandlerLinks } from './overlay-tsmorph'
+import { buildHandlerLinks, buildSchemaAnnotations, buildSourceSpans } from './overlay-tsmorph'
 
 test('resolves authorization hooks from imported remote method definitions', () => {
   const root = mkdtempSync(join(tmpdir(), 'astrale-studio-handler-links-'))
@@ -102,3 +102,166 @@ test('resolves authorization hooks from imported remote method definitions', ()
     rmSync(root, { recursive: true, force: true })
   }
 })
+
+test('links current implementation handlers and current edge source spans', () => {
+  const root = mkdtempSync(join(tmpdir(), 'astrale-studio-current-overlay-'))
+  const schemaDir = join(root, 'schema')
+  const actionsDir = join(root, 'actions')
+  mkdirSync(schemaDir)
+  mkdirSync(actionsDir)
+  writeFileSync(
+    join(root, 'package.json'),
+    JSON.stringify({ imports: { '#actions/*': './actions/*.ts' } }),
+  )
+
+  writeFileSync(
+    join(root, 'implementation.ts'),
+    `
+      import { rename } from '#actions/rename'
+      import { createIssue } from '#actions/create-issue'
+      export const domain = defineDomain.public({
+        schema,
+        handlers: {
+          functions: { createIssue },
+          classes: { Issue: { rename } },
+          interfaces: {},
+        },
+      })
+    `,
+  )
+  writeFileSync(
+    join(actionsDir, 'rename.ts'),
+    `
+      export function rename({ input }) {
+        return graph.update(input)
+      }
+    `,
+  )
+  writeFileSync(
+    join(actionsDir, 'create-issue.ts'),
+    `export const createIssue = ({ input }) => graph.create(input)`,
+  )
+  writeFileSync(
+    join(schemaDir, 'members.ts'),
+    `
+      export const iIssue = nodeInterface({
+        properties: { title: property({ type: 'string' }) },
+      })
+      export const Issue = nodeClass({
+        properties: { title: property({ type: 'string' }) },
+        methods: { rename },
+      })
+      export const assigned_to = edgeClass.directed({
+        source: { as: 'issue', accepts: [Issue], outgoing: '0..*' },
+        target: { as: 'owner', accepts: [Issue], incoming: '0..1' },
+        properties: { note: property({ type: 'string' }) },
+      })
+      export const createIssue = fn({ auth: 'anonymous', input, output })
+    `,
+  )
+  writeFileSync(
+    join(schemaDir, 'index.ts'),
+    `
+      import { Issue, assigned_to, createIssue, iIssue as issueInterface } from './members.js'
+      const schemaInput = {
+        interfaces: { Issue: issueInterface },
+        classes: { Issue, assigned_to },
+        functions: { createIssue },
+      } as const
+      export const schema = defineSchema('issues.example', schemaInput)
+    `,
+  )
+
+  try {
+    const links = buildHandlerLinks({
+      ir: {
+        version: 'v1',
+        domain: 'issues.example',
+        types: {},
+        interfaces: {},
+        classes: {
+          Issue: {
+            type: 'node',
+            name: 'Issue',
+            properties: {},
+            methods: {
+              rename: {
+                name: 'rename',
+                params: {},
+                returns: {},
+                static: false,
+                inheritance: 'default',
+                auth: 'authorized',
+              } as any,
+            },
+          },
+        },
+        imports: {},
+        functions: {
+          createIssue: {
+            name: 'createIssue',
+            input: {},
+            params: {},
+            output: { mode: 'value', schema: {} },
+            returns: {},
+            static: true,
+            inheritance: 'default',
+            auth: 'anonymous',
+          },
+        },
+      },
+      domainRoot: root,
+    })
+    expect(links).toHaveLength(2)
+    expect(links.find((link) => link.ownerKind === 'class')).toMatchObject({
+      owner: 'Issue',
+      ownerKind: 'class',
+      method: 'rename',
+      wiringFile: 'implementation.ts',
+      handlerFile: 'actions/rename.ts',
+      implemented: true,
+      auth: 'required',
+      callableAuth: 'authorized',
+      authorize: 'custom',
+      kernelCalls: ['graph.update'],
+    })
+    expect(links.find((link) => link.ownerKind === 'function')).toMatchObject({
+      owner: 'issues.example',
+      method: 'createIssue',
+      wiringFile: 'implementation.ts',
+      handlerFile: 'actions/create-issue.ts',
+      implemented: true,
+      static: true,
+      auth: 'public',
+      callableAuth: 'anonymous',
+      kernelCalls: ['graph.create'],
+    })
+
+    const spans = buildSourceSpans({ ir: null, schemaDir })
+    expect(spans['interface.Issue.property.title']?.file).toBe('schema/members.ts')
+    expect(spans['class.Issue.property.title']?.file).toBe('schema/members.ts')
+    expect(spans['edge.assigned_to.endpoint.issue']?.file).toBe('schema/members.ts')
+    expect(spans['edge.assigned_to.endpoint.owner']?.file).toBe('schema/members.ts')
+    expect(spans['edge.assigned_to.property.note']?.file).toBe('schema/members.ts')
+    expect(spans['function.createIssue']?.file).toBe('schema/members.ts')
+  } finally {
+    rmSync(root, { recursive: true, force: true })
+  }
+})
+
+test('does not emit the obsolete enum update warning', () => {
+  expect(
+    buildSchemaAnnotations({
+      ir: {
+        classes: {
+          Issue: {
+            type: 'node',
+            name: 'Issue',
+            properties: { status: { type: 'string', enum: ['open', 'closed'] } },
+            methods: {},
+          },
+        },
+      } as any,
+    }),
+  ).toEqual([])
+})