@astrale-os/cli 1.0.0-beta.2 → 1.0.0-beta.20

package/studio/server/introspect/anatomy-extras.test.ts

@@ -46,7 +46,7 @@ test('reads the discovered client directory', () => {
   })
 })
 
-test('resolves views declared in the registry file itself', () => {
+test('does not treat a removed view registry as Schema authority', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-inline-view-registry-'))
   roots.push(root)
   const viewsDir = join(root, 'views')
@@ -68,29 +68,10 @@ export const views = { services, service }
 `,
   )
 
-  expect(buildViews(root)).toEqual([
-    {
-      slug: 'services',
-      kind: 'spa',
-      url: undefined,
-      file: 'views/index.ts',
-      auth: 'required',
-      mount: '/ui/services',
-      description: 'Browse services.',
-    },
-    {
-      slug: 'service',
-      kind: 'spa',
-      url: undefined,
-      file: 'views/index.ts',
-      auth: 'required',
-      mount: '/ui/service',
-      viewFor: 'CloudflareWorker',
-    },
-  ])
+  expect(buildViews(root)).toEqual([])
 })
 
-test('joins canonical Bundle Views with reactFrontend route metadata', () => {
+test('joins canonical Bundle Views with defineFrontend route metadata', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-current-react-view-'))
   roots.push(root)
   mkdirSync(join(root, 'schema', 'application'), { recursive: true })
@@ -118,11 +99,13 @@ export const schema = defineSchema(ORIGIN, schemaInput)
   )
   writeFileSync(
     join(root, 'views', 'routes.ts'),
-    `import { reactFrontend, reactRoute } from '@astrale-os/sdk/react'
-const routes = {
-  issue: reactRoute({ path: '/ui/issues/:id', component: { module: './views/issue.tsx' } }),
-}
-export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
+    `import { defineFrontend, vite } from '@astrale-os/sdk/application'
+export const frontend = defineFrontend({
+  schema,
+  source: vite(),
+  routes: { issue: '/ui/issues/:id' },
+  entrypoint: 'issue',
+})
 `,
   )
 
@@ -137,7 +120,7 @@ export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
           kind: 'definition',
           definitions: [
             { origin: 'issues.example.dev', kind: 'class', name: 'Issue' },
-            { origin: 'accounts.example.dev', kind: 'interface', name: 'Group' },
+            { origin: 'accounts.example.dev', kind: 'class', name: 'Group' },
           ],
         },
       },
@@ -156,7 +139,7 @@ export const frontend = reactFrontend({ schema, routes, entrypoint: 'issue' })
   ])
 })
 
-test('discovers generated frontend routes without deriving canonical View defaults', () => {
+test('discovers Vite frontend default routes from canonical View names', () => {
   const root = mkdtempSync(join(tmpdir(), 'studio-current-generated-view-'))
   roots.push(root)
   mkdirSync(join(root, 'schema'), { recursive: true })
@@ -170,11 +153,10 @@ test('discovers generated frontend routes without deriving canonical View defaul
   )
   writeFileSync(
     join(root, 'views', 'summary', 'index.ts'),
-    `const source = generatedFrontend({ files: [{ path: 'index.html', content: '<h1>Hi</h1>' }] })
-export const frontend = frontendArtifact({
+    `const source = vite()
+export const frontend = defineFrontend({
   schema,
   source,
-  routes: { summary: frontendRoute({}) },
   entrypoint: 'summary',
 })
 `,
@@ -191,9 +173,9 @@ export const frontend = frontendArtifact({
   ).toEqual([
     {
       slug: 'summary',
-      kind: 'inline-html',
+      kind: 'spa',
       auth: 'required',
-      mount: '/ui/summary',
+      mount: '/summary',
       url: undefined,
       file: 'views/summary/index.ts',
     },
@@ -215,12 +197,13 @@ test('canonical Bundle views reject static schema and route-only identities', ()
 })`,
   )
   writeFileSync(
-    join(root, 'implementation.ts'),
-    `export const frontend = frontendArtifact({
-  source: externalFrontend({ href: 'https://shell.example.dev' }),
+    join(root, 'application.ts'),
+    `export const frontend = defineFrontend({
+  schema,
+  source: external('https://shell.example.dev'),
   routes: {
-    account: frontendRoute({ href: 'https://shell.example.dev/account' }),
-    routeOnly: frontendRoute({ href: 'https://shell.example.dev/route-only' }),
+    account: '/account',
+    routeOnly: '/route-only',
   },
 })`,
   )
@@ -251,14 +234,15 @@ test('canonical Bundle views reject static schema and route-only identities', ()
       description: 'Admitted account view.',
       viewFor: 'Account',
       url: 'https://shell.example.dev/account',
-      file: 'implementation.ts',
+      file: 'application.ts',
     },
     {
       slug: 'sourceOnly',
-      kind: 'unknown',
+      kind: 'spa',
       auth: 'optional',
       description: 'Admitted source-only view.',
-      file: 'schema/index.ts',
+      url: 'https://shell.example.dev/source-only',
+      file: 'application.ts',
     },
   ])
   expect(buildViews(root, 'schema', {})).toEqual([])

package/studio/server/introspect/anatomy.test.ts

@@ -6,28 +6,36 @@ import { join } from 'node:path'
 import { buildAnatomy } from './anatomy'
 
 const roots: string[] = []
-
 afterEach(() => {
   for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true })
 })
 
-function project(entry: 'implementation.ts' | 'domain.ts') {
-  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-entry-'))
+function project(nested: boolean) {
+  const root = mkdtempSync(join(tmpdir(), 'studio-anatomy-application-'))
   roots.push(root)
-  mkdirSync(join(root, 'schema'), { recursive: true })
+  const owner = nested ? join(root, 'domain') : root
+  mkdirSync(join(owner, 'schema'), { recursive: true })
   writeFileSync(join(root, 'package.json'), '{}\n')
-  writeFileSync(join(root, 'astrale.config.ts'), 'export default {}\n')
-  writeFileSync(join(root, entry), 'export const domain = {}\n')
-  writeFileSync(join(root, 'schema/index.ts'), "defineSchema('example.astrale.ai', {})\n")
-  return root
+  writeFileSync(
+    join(root, 'astrale.config.ts'),
+    nested
+      ? "import application from './domain/application.js'\nexport default { application }\n"
+      : 'export default {}\n',
+  )
+  writeFileSync(join(owner, 'application.ts'), 'export const application = {}\n')
+  writeFileSync(
+    join(owner, 'schema/index.ts'),
+    "defineSchema('example.astrale.ai', { classes: {} })\n",
+  )
+  return { root, schemaDirName: nested ? 'domain/schema' : 'schema' }
 }
 
-test('overview anchors current projects to implementation.ts', () => {
-  const anatomy = buildAnatomy({ root: project('implementation.ts'), schemaDirName: 'schema' })
-  expect(anatomy.overview.compositionFile).toBe('implementation.ts')
+test('overview anchors a root Application', () => {
+  const input = project(false)
+  expect(buildAnatomy(input).overview.applicationFile).toBe('application.ts')
 })
 
-test('overview preserves domain.ts as the legacy composition entry', () => {
-  const anatomy = buildAnatomy({ root: project('domain.ts'), schemaDirName: 'schema' })
-  expect(anatomy.overview.compositionFile).toBe('domain.ts')
+test('overview preserves the config-imported nested Application path', () => {
+  const input = project(true)
+  expect(buildAnatomy(input).overview.applicationFile).toBe('domain/application.ts')
 })

package/studio/server/introspect/anatomy.ts

@@ -12,6 +12,7 @@ import { join, relative } from 'node:path'
 
 import type { DomainAnatomy, DomainOverview, SchemaIR } from '../../shared/types'
 
+import { resolveApplicationEntry } from '../domain'
 import { asJsonRecord, asString, parseJson } from '../json'
 import { readSettings } from '../state/settings'
 import { buildClientTree, buildEnvFields, buildViews, findSchemaDefinition } from './anatomy-extras'
@@ -59,15 +60,11 @@ function buildOverview(
 
   const config = readConfigPreview(root)
 
-  const compositionFile = existsSync(join(root, 'implementation.ts'))
-    ? 'implementation.ts'
-    : existsSync(join(root, 'domain.ts'))
-      ? 'domain.ts'
-      : undefined
-  const domainSrc = compositionFile ? readTextSafe(join(root, compositionFile)) : ''
+  const application = resolveApplicationEntry(root)
+  const applicationSrc = application === null ? '' : readTextSafe(application)
   const origin =
     schemaOrigin ??
-    domainSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
+    applicationSrc.match(/defineSchema\(\s*['"]([^'"]+)['"]/)?.[1] ??
     readTextSafe(join(root, schemaDirName, 'index.ts')).match(
       /defineSchema\(\s*['"]([^'"]+)['"]/,
     )?.[1] ??
@@ -75,11 +72,11 @@ function buildOverview(
 
   return {
     origin,
-    compositionFile,
+    applicationFile:
+      application === null ? undefined : relative(root, application).replaceAll('\\', '/'),
     adapter: config.adapter,
     prodTarget: config.prodTarget,
     devSecrets: config.devSecrets,
-    postInstall: undefined,
     requires: [],
     packageName: pkg?.name,
     packageVersion: pkg?.version,

package/studio/server/introspect/bundle.ts

@@ -18,7 +18,6 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
   let schemaRoot: unknown | undefined
   let schemaMode: StudioSchemaBundle['schemaMode'] = 'unavailable'
   let schemaRevision: StudioSchemaBundle['schemaRevision']
-  let importedInterfaces: StudioSchemaBundle['importedInterfaces']
   let error: StudioSchemaBundle['error'] = null
   let extractedBy: StudioSchemaBundle['extractedBy'] = 'runtime-bun'
 
@@ -33,7 +32,6 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
       if (r.root !== null) schemaRoot = r.root
       schemaMode = r.schemaMode
       if (r.revision !== null) schemaRevision = r.revision
-      importedInterfaces = r.importedInterfaces
     } else {
       error = { message: r.error?.message ?? 'schema failed to compile' }
       extractedBy = 'static-tsmorph-fallback'
@@ -65,7 +63,6 @@ export async function buildBundle(handle: DomainHandle): Promise<StudioSchemaBun
     ir,
     ...(schemaRoot === undefined ? {} : { schemaRoot }),
     overlay,
-    importedInterfaces,
     error,
     extractedAt: new Date().toISOString(),
   }