@astrale-os/cli 1.0.0-beta.3 → 1.0.0-beta.30

package/studio/server/introspect/canonical-schema.test.ts

@@ -1,474 +1,205 @@
+import * as sdk from '@astrale-os/sdk/schema'
+import {
+  core,
+  defineSchema,
+  edgeClass,
+  func,
+  method,
+  nodeClass,
+  output,
+  property,
+  valueSchema,
+  view,
+} from '@astrale-os/sdk/schema'
 import { describe, expect, test } from 'bun:test'
 
-import type { CanonicalDomainSchemaV1 } from './canonical-schema'
-
 import {
-  closureFromSdk,
+  extractCanonicalSchemaFromSdk,
   findCanonicalDomainSchemaExport,
-  normalizeLegacySchemaIR,
+  isCanonicalDomainSchemaV1,
   projectCanonicalCore,
-  projectCanonicalSchema,
+  type CanonicalDomainSchemaV1,
 } from './canonical-schema'
 
-const emptyProperties = {
-  type: 'object',
-  properties: {},
-  required: [],
-  additionalProperties: false,
-}
-
-const dependency = {
-  format: 'astrale.dsl',
-  version: 'v1',
-  origin: 'directory.example.dev',
-  dependencies: [],
-  types: {},
-  interfaces: {
-    Named: {
-      family: 'node',
-      extends: [],
-      properties: {
-        ...emptyProperties,
-        properties: { name: { type: 'string' } },
-        required: ['name'],
-      },
-      propertyMetadata: {},
-      methods: {},
-    },
-  },
-  classes: {},
-  functions: {},
-  policies: {},
-  views: {},
-  core: { nodes: {}, edges: [] },
-} satisfies CanonicalDomainSchemaV1
-
-const namedRef = {
-  origin: dependency.origin,
-  kind: 'interface',
-  name: 'Named',
-} as const
-const namedKey = `${dependency.origin}:interface.Named` as const
-const documentRef = {
-  origin: 'documents.example.dev',
-  kind: 'class',
-  name: 'Document',
-} as const
+const string = valueSchema<string>()({ type: 'string' })
+const boolean = valueSchema<boolean>()({ type: 'boolean' })
+const rename = method({
+  input: valueSchema<{ title: string }>()({
+    type: 'object',
+    properties: { title: { type: 'string' } },
+    required: ['title'],
+    additionalProperties: false,
+  }),
+  output: boolean,
+  auth: 'authorized',
+})
 
-const root = {
-  format: 'astrale.dsl',
-  version: 'v1',
-  origin: 'documents.example.dev',
-  dependencies: [{ origin: dependency.origin, revision: `sha256:${'1'.repeat(64)}` }],
-  types: { State: { type: 'string', enum: ['draft', 'published'] } },
-  interfaces: {
-    Publishable: {
-      family: 'node',
-      extends: [namedRef],
-      properties: emptyProperties,
-      propertyMetadata: {},
-      methods: {},
-    },
-  },
-  classes: {
-    Document: {
-      family: 'node',
-      implements: [{ origin: 'documents.example.dev', kind: 'interface', name: 'Publishable' }],
-      properties: {
-        ...emptyProperties,
-        properties: {
-          title: { type: 'string' },
-          summary: { type: 'string' },
-          note: { type: ['string', 'null'] },
-        },
-        required: ['title', 'note'],
-      },
-      propertyMetadata: {},
-      data: { mediaType: 'application/json', indexed: true },
-      methods: {
-        watch: {
-          input: {
-            ...emptyProperties,
-            properties: { cursor: { type: 'string' }, limit: { type: 'integer' } },
-            required: ['cursor'],
-          },
-          output: { mode: 'stream', item: { type: 'string' } },
-          auth: 'authorized',
-          static: false,
-          inheritance: 'default',
-        },
-      },
-      policies: {},
-    },
-    references: {
-      family: 'edge',
-      implements: [],
-      properties: emptyProperties,
-      propertyMetadata: {},
-      orientation: 'directed',
-      endpoints: {
-        source: { role: 'document', accepts: [documentRef], outgoing: '1..*' },
-        target: { role: 'named', accepts: [namedRef], incoming: '0..1' },
-      },
-      policies: {},
-      constraints: { noSelf: true },
-    },
-  },
+const Named = nodeClass({ properties: { title: string } })
+const dependency = defineSchema('shared.example.dev', { classes: { Named } })
+const Document = nodeClass({
+  description: 'A document.',
+  icon: '<svg />',
+  extends: [Named],
+  properties: { slug: property(string, { description: 'Stable slug.' }) },
+  methods: { rename },
+})
+const links = edgeClass.directed({
+  source: { as: 'source', accepts: [Document], outgoing: '1' },
+  target: { as: 'target', accepts: [Named], incoming: '0..*' },
+})
+const primary = core.node(Document, { slug: 'primary', title: 'Primary' })
+const primaryLink = core.edge(primary, links, primary, {})
+const schema = defineSchema('docs.example.dev', {
+  dependencies: { shared: dependency },
+  classes: { Document, links },
   functions: {
-    exportAll: {
-      description: 'Export every document.',
-      input: emptyProperties,
-      output: { mode: 'binary' },
-      auth: 'authenticated',
-    },
-  },
-  policies: {},
-  views: {
-    editor: {
-      description: 'Document editor',
-      target: { kind: 'definition', definitions: [documentRef, namedRef] },
-      auth: 'optional',
-    },
-  },
-  core: {
-    nodes: {
-      welcome: {
-        class: documentRef,
-        properties: {
-          'documents.example.dev:class.Document.property.title': 'Welcome',
-        },
-      },
-    },
-    edges: [
-      {
-        class: { origin: 'documents.example.dev', kind: 'class', name: 'references' },
-        source: { origin: 'documents.example.dev', kind: 'core', name: 'welcome' },
-        target: { kind: 'domain' },
-        properties: { weight: 1 },
-      },
-    ],
+    search: func({ input: string, output: output.stream(string), auth: 'authenticated' }),
   },
-} satisfies CanonicalDomainSchemaV1
-
-describe('canonical DomainSchema V1 projection', () => {
-  test('admits only an SDK-verified, exact dependency closure', () => {
-    expect(
-      closureFromSdk({ bundle: { create: () => ({ root, closure: [dependency] }) } }, root),
-    ).toEqual([dependency])
-
-    expect(
-      closureFromSdk(
-        {
-          bundle: { create: () => ({ root: dependency, closure: [dependency] }) },
-          schema: { resolve: () => ({ $: { schema: root, closure: [dependency] } }) },
-        },
-        root,
-      ),
-    ).toEqual([dependency])
-
-    expect(
-      closureFromSdk({ bundle: { create: () => ({ root, closure: [root, dependency] }) } }, root),
-    ).toEqual([])
-  })
+  views: { documents: view({ target: Document }) },
+  core: { nodes: { primary }, edges: [primaryLink] },
+})
+const namedRef = { origin: dependency.origin, kind: 'class', name: 'Named' } as const
+const documentRef = { origin: schema.origin, kind: 'class', name: 'Document' } as const
 
-  test('finds any directly exported V1 root while preferring `schema`', () => {
-    expect(findCanonicalDomainSchemaExport({ Other: dependency, schema: root })).toBe(root)
-    expect(findCanonicalDomainSchemaExport({ Current: root })).toBe(root)
-    expect(findCanonicalDomainSchemaExport({ schema: { kind: 'legacy' } })).toBeNull()
-  })
+const sdkModule = sdk
 
-  test('keeps legacy fields and enriches refs, callables, views, and imported interfaces', () => {
-    const projected = projectCanonicalSchema(root, [dependency])
-    const ir = projected.ir
+describe('canonical Schema projection', () => {
+  test('recognizes exported V1 roots and preserves an invalid root as a preview', () => {
+    expect(isCanonicalDomainSchemaV1(schema)).toBe(true)
+    expect(findCanonicalDomainSchemaExport({ other: dependency, schema })).toBe(schema)
 
-    expect(ir).toMatchObject({
+    const invalid = {
       format: 'astrale.dsl',
       version: 'v1',
-      domain: root.origin,
-      dependencies: root.dependencies,
-    })
-    expect(ir.interfaces.Publishable.extends).toEqual(['Named'])
-    expect(ir.interfaces.Publishable.extendsRefs).toEqual([namedRef])
-    expect(ir.imports.Named).toEqual({
-      origin: dependency.origin,
-      definition: 'interface',
-      ref: namedRef,
-      key: namedKey,
-    })
-    expect(ir.importsByKey?.[namedKey]).toEqual(ir.imports.Named)
-    expect(ir.importedInterfacesByKey?.[namedKey]).toMatchObject({
-      name: 'Named',
-      origin: dependency.origin,
-    })
-    expect(projected.importedInterfaces.Named).toMatchObject({
-      name: 'Named',
-      origin: dependency.origin,
-      family: 'node',
-      properties: { name: { type: 'string' } },
-      required: ['name'],
+      origin: 'not an origin',
+      dependencies: {},
+      classes: {},
+      functions: {},
+      policies: {},
+      views: {},
+      core: { nodes: {}, edges: [] },
+    } as CanonicalDomainSchemaV1
+    expect(extractCanonicalSchemaFromSdk(sdkModule, invalid)).toMatchObject({
+      status: 'preview',
+      revision: null,
+      ir: { domain: 'not an origin' },
     })
+  })
 
-    expect(ir.classes.Document.properties).toEqual({
-      title: { type: 'string' },
-      summary: { type: 'string' },
-      note: { type: ['string', 'null'] },
-    })
-    expect(ir.classes.Document.required).toEqual(['title', 'note'])
-    expect(ir.classes.Document.data).toEqual({ mediaType: 'application/json', indexed: true })
-    expect(ir.classes.Document.methods.watch).toMatchObject({
-      name: 'watch',
-      auth: 'authorized',
-      static: false,
-      inheritance: 'default',
-      params: {
-        cursor: { type: 'string' },
-        limit: { type: 'integer' },
+  test('uses the resolved Domain for Classes, dependency footprint, callables, and Views', () => {
+    const extraction = extractCanonicalSchemaFromSdk(sdkModule, schema)
+    expect(extraction.status).toBe('admitted')
+    expect(extraction.revision).toMatch(/^sha256:[0-9a-f]{64}$/)
+    expect(extraction.ir.classes.Document).toMatchObject({
+      icon: '<svg />',
+      extendsRefs: [namedRef],
+      properties: { slug: { type: 'string' } },
+      required: ['slug'],
+      propertyMetadata: {
+        slug: { required: true, visibility: 'public', description: 'Stable slug.' },
       },
-      requiredParams: ['cursor'],
-      output: { mode: 'stream', item: { type: 'string' } },
-      returns: { type: 'string' },
+      methods: {
+        rename: {
+          input: { required: ['title'] },
+          auth: 'authorized',
+          output: { mode: 'value', schema: { type: 'boolean' } },
+        },
+      },
+    })
+    expect(extraction.ir.importsByKey['shared.example.dev:class.Named']).toEqual({
+      origin: namedRef.origin,
+      ref: namedRef,
+      key: 'shared.example.dev:class.Named',
     })
-    expect(ir.classes.references.endpoints).toEqual([
+    expect(
+      extraction.ir.importedClassesByKey['shared.example.dev:class.Named']?.properties.title,
+    ).toEqual({ type: 'string' })
+    expect(extraction.ir.classes.links.endpoints).toEqual([
       {
-        name: 'document',
+        name: 'source',
         types: ['Document'],
         refs: [documentRef],
-        cardinality: { min: 1, max: null },
+        cardinality: { min: 1, max: 1 },
       },
       {
-        name: 'named',
+        name: 'target',
         types: ['Named'],
         refs: [namedRef],
-        cardinality: { min: 0, max: 1 },
+        cardinality: { min: 0, max: null },
       },
     ])
-    expect(ir.functions.exportAll).toMatchObject({
-      name: 'exportAll',
+    expect(extraction.ir.functions.search).toMatchObject({
       auth: 'authenticated',
-      static: true,
-      inheritance: 'default',
-      params: {},
-      requiredParams: [],
-      output: { mode: 'binary' },
-      returns: {},
-    })
-    expect(ir.views?.editor).toEqual({
-      name: 'editor',
-      description: 'Document editor',
-      target: { kind: 'definition', definitions: [documentRef, namedRef] },
-      auth: 'optional',
+      output: { mode: 'stream' },
     })
-    expect(ir.core).toEqual(root.core)
-  })
-
-  test('keeps colliding imported definitions under exact DSL Keys only', () => {
-    const alternate = {
-      ...dependency,
-      origin: 'people.example.dev',
-    } satisfies CanonicalDomainSchemaV1
-    const classOwner = {
-      ...dependency,
-      origin: 'catalog.example.dev',
-      interfaces: {},
-      classes: {
-        Named: {
-          family: 'node',
-          implements: [],
-          properties: emptyProperties,
-          propertyMetadata: {},
-          methods: {},
-          policies: {},
-        },
-      },
-    } satisfies CanonicalDomainSchemaV1
-    const alternateRef = {
-      origin: alternate.origin,
-      kind: 'interface',
-      name: 'Named',
-    } as const
-    const classRef = {
-      origin: classOwner.origin,
-      kind: 'class',
-      name: 'Named',
-    } as const
-    const collisionRoot = {
-      format: 'astrale.dsl',
-      version: 'v1',
-      origin: 'collisions.example.dev',
-      dependencies: [],
-      types: {},
-      interfaces: {
-        Local: {
-          family: 'node',
-          extends: [namedRef, alternateRef],
-          properties: emptyProperties,
-          propertyMetadata: {},
-          methods: {},
-        },
-      },
-      classes: {},
-      functions: {},
-      policies: {},
-      views: {
-        everything: {
-          target: { kind: 'definition', definitions: [namedRef, alternateRef, classRef] },
-          auth: 'required',
-        },
-      },
-      core: { nodes: {}, edges: [] },
-    } satisfies CanonicalDomainSchemaV1
-
-    const projected = projectCanonicalSchema(collisionRoot, [dependency, alternate, classOwner])
-    const keys = [
-      'directory.example.dev:interface.Named',
-      'people.example.dev:interface.Named',
-      'catalog.example.dev:class.Named',
-    ]
-
-    expect(Object.keys(projected.ir.importsByKey ?? {}).sort()).toEqual(keys.sort())
-    expect(Object.keys(projected.ir.importedInterfacesByKey ?? {}).sort()).toEqual(
-      keys.filter((key) => key.includes(':interface.')).sort(),
-    )
-    expect(
-      projected.ir.importedInterfacesByKey?.['directory.example.dev:interface.Named']?.origin,
-    ).toBe('directory.example.dev')
-    expect(
-      projected.ir.importedInterfacesByKey?.['people.example.dev:interface.Named']?.origin,
-    ).toBe('people.example.dev')
-    expect(projected.ir.importsByKey?.['catalog.example.dev:class.Named']).toMatchObject({
-      definition: 'class',
-      key: 'catalog.example.dev:class.Named',
-      ref: classRef,
-    })
-    expect(projected.ir.imports.Named).toBeUndefined()
-    expect(projected.importedInterfaces.Named).toBeUndefined()
-  })
-
-  test('collects an exact external Definition referenced only by a top-level Policy', () => {
-    const policyOrigin = 'authorization.example.dev'
-    const subjectRef = { origin: policyOrigin, kind: 'class', name: 'Subject' } as const
-    const objectRef = { origin: policyOrigin, kind: 'class', name: 'Object' } as const
-    const policyOnlyRef = { origin: policyOrigin, kind: 'class', name: 'may_access' } as const
-    const policyDependency = {
-      format: 'astrale.dsl',
-      version: 'v1',
-      origin: policyOrigin,
-      dependencies: [],
-      types: {},
-      interfaces: {},
-      classes: {
-        Subject: {
-          family: 'node',
-          implements: [],
-          properties: emptyProperties,
-          propertyMetadata: {},
-          methods: {},
-          policies: {},
-        },
-        Object: {
-          family: 'node',
-          implements: [],
-          properties: emptyProperties,
-          propertyMetadata: {},
-          methods: {},
-          policies: {},
-        },
-        may_access: {
-          family: 'edge',
-          implements: [],
-          properties: emptyProperties,
-          propertyMetadata: {},
-          orientation: 'directed',
-          endpoints: {
-            source: { role: 'subject', accepts: [subjectRef], outgoing: '0..*' },
-            target: { role: 'object', accepts: [objectRef], incoming: '0..*' },
-          },
-          policies: {},
-          constraints: {},
-        },
-      },
-      functions: {},
-      policies: {},
-      views: {},
-      core: { nodes: {}, edges: [] },
-    } satisfies CanonicalDomainSchemaV1
-    const policyOnlyRoot = {
-      format: 'astrale.dsl',
-      version: 'v1',
-      origin: 'policy-consumer.example.dev',
-      dependencies: [{ origin: policyDependency.origin, revision: `sha256:${'2'.repeat(64)}` }],
-      types: {},
-      interfaces: {},
-      classes: {},
-      functions: {},
-      policies: {
-        canRead: {
-          match: {
-            source: { kind: 'subject' },
-            class: policyOnlyRef,
-            target: { kind: 'object' },
-          },
-        },
-      },
-      views: {},
-      core: { nodes: {}, edges: [] },
-    } satisfies CanonicalDomainSchemaV1
-
-    const projected = projectCanonicalSchema(policyOnlyRoot, [policyDependency])
-    expect(projected.ir.importsByKey?.['authorization.example.dev:class.may_access']).toEqual({
-      origin: policyDependency.origin,
-      definition: 'class',
-      ref: policyOnlyRef,
-      key: 'authorization.example.dev:class.may_access',
+    expect(extraction.ir.views.documents.target).toEqual({
+      kind: 'definition',
+      definitions: [documentRef],
     })
+    expect(extraction.ir.dependencies).toEqual([
+      { origin: dependency.origin, revision: sdk.schema.revision(dependency) },
+    ])
   })
 
-  test('projects canonical core paths and the owning Domain endpoint', () => {
-    expect(projectCanonicalCore(root)).toEqual({
-      domain: root.origin,
+  test('projects Core from the same admitted root without a second Schema import', () => {
+    const extraction = extractCanonicalSchemaFromSdk(sdkModule, schema)
+    expect(projectCanonicalCore(extraction.root)).toEqual({
+      domain: schema.origin,
       nodes: [
         {
-          path: '/:documents.example.dev:core.welcome',
+          path: '/:docs.example.dev:core.primary',
           className: 'Document',
-          data: { 'documents.example.dev:class.Document.property.title': 'Welcome' },
+          data: {
+            'docs.example.dev:class.Document.property.slug': 'primary',
+            'shared.example.dev:class.Named.property.title': 'Primary',
+          },
         },
       ],
       edges: [
         {
-          from: '/:documents.example.dev:core.welcome',
-          to: '/:documents.example.dev',
-          edgeName: 'references',
-          data: { weight: 1 },
+          from: '/:docs.example.dev:core.primary',
+          to: '/:docs.example.dev:core.primary',
+          edgeName: 'links',
+          data: {},
         },
       ],
     })
   })
 
-  test('normalizes a legacy IR to the required standalone-function shape', () => {
-    const ir = normalizeLegacySchemaIR({
-      version: '1.0',
-      domain: 'legacy.example.dev',
-      types: {},
-      interfaces: {},
-      classes: {},
-      imports: {},
-      functions: {
-        legacy: {
-          params: {
-            required: { type: 'string' },
-            maybe: { type: ['string', 'null'] },
-          },
-          returns: { type: 'boolean' },
+  test('delegates admission, resolution, and dependency reachability to the DSL', () => {
+    const calls: string[] = []
+    const wrapped = {
+      ...sdk,
+      bundle: {
+        ...sdk.bundle,
+        create(value: typeof schema) {
+          calls.push('bundle.create')
+          return sdk.bundle.create(value)
+        },
+        accept(value: unknown) {
+          calls.push('bundle.accept')
+          return sdk.bundle.accept(value)
         },
       },
-    })
-    expect(ir.functions.legacy).toMatchObject({
-      params: {
-        required: { type: 'string' },
-        maybe: { type: ['string', 'null'] },
+      schema: {
+        ...sdk.schema,
+        resolve(value: typeof schema) {
+          calls.push('schema.resolve')
+          return sdk.schema.resolve(value)
+        },
+        compareDependencyMeaning(source: typeof schema, target: typeof dependency) {
+          calls.push('schema.compareDependencyMeaning')
+          return sdk.schema.compareDependencyMeaning(source, target)
+        },
       },
-      requiredParams: ['required'],
-      input: { required: ['required'] },
-    })
+    } as unknown as typeof sdk
+
+    expect(extractCanonicalSchemaFromSdk(wrapped, schema).status).toBe('admitted')
+    expect(calls).toEqual([
+      'bundle.create',
+      'bundle.accept',
+      'schema.resolve',
+      'schema.compareDependencyMeaning',
+    ])
   })
 })