@stream44.studio/t44 0.4.0-rc.24

package/caps/OpenApiSchema.ts

@@ -0,0 +1,67 @@
+import { join } from 'node:path'
+import { mkdir, readFile, writeFile } from 'node:fs/promises'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                WorkspaceConfig: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/WorkspaceConfig'
+                },
+                url: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: undefined,
+                },
+                schemas: {
+                    type: CapsulePropertyTypes.Literal,
+                    value: {}
+                },
+                ensureCached: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<any | null> {
+                        if (!this.url) return null
+
+                        const cacheDir = join(
+                            this.WorkspaceConfig.workspaceRootDir,
+                            '.~o',
+                            'workspace.foundation',
+                            'OpenApiSchemas',
+                        )
+
+                        await mkdir(cacheDir, { recursive: true })
+
+                        const schemaFile = join(cacheDir, this.url.replace(/\//g, '~'))
+
+                        try {
+                            const cached = await readFile(schemaFile, 'utf-8')
+                            return JSON.parse(cached)
+                        } catch (error) {
+                            const response = await fetch(this.url)
+                            if (!response.ok) {
+                                return null
+                            }
+                            const openApiSpec = await response.json()
+                            await writeFile(schemaFile, JSON.stringify(openApiSpec, null, 2))
+                            return openApiSpec
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/OpenApiSchema'

package/caps/PackageDescriptor.ts

@@ -0,0 +1,88 @@
+
+import { join } from 'path'
+import { readFile, writeFile } from 'fs/promises'
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#': {
+                JsonSchema: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/JsonSchemas'
+                },
+                RegisterSchemas: {
+                    type: CapsulePropertyTypes.StructInit,
+                    value: async function (this: any): Promise<void> {
+                        if (this.schema?.schema) {
+                            const version = this.schemaMinorVersion || '0'
+                            await this.JsonSchema.registerSchema(this.capsuleName, this.schema.schema, version)
+                        }
+                    }
+                },
+                _readPackageJson: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string): Promise<any> {
+                        const content = await readFile(packageJsonPath, 'utf-8')
+                        return JSON.parse(content)
+                    }
+                },
+                _writePackageJson: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string, pkg: any): Promise<void> {
+                        await writeFile(packageJsonPath, JSON.stringify(pkg, null, 4) + '\n')
+                    }
+                },
+                _resolveConfigSection: {
+                    type: CapsulePropertyTypes.Function,
+                    value: function (this: any, pkg: any): any {
+                        const structKey = this.capsuleName
+                        if (!pkg.config) return undefined
+                        if (!pkg.config.o) return undefined
+                        if (!pkg.config.o['workspace.foundation']) return undefined
+                        return pkg.config.o['workspace.foundation'][structKey] || undefined
+                    }
+                },
+                get: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string): Promise<any | null> {
+                        try {
+                            const pkg = await this._readPackageJson(packageJsonPath)
+                            return this._resolveConfigSection(pkg) || null
+                        } catch {
+                            return null
+                        }
+                    }
+                },
+                set: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, packageJsonPath: string, data: any): Promise<void> {
+                        const pkg = await this._readPackageJson(packageJsonPath)
+                        const structKey = this.capsuleName
+
+                        if (!pkg.config) pkg.config = {}
+                        if (!pkg.config.o) pkg.config.o = {}
+                        if (!pkg.config.o['workspace.foundation']) pkg.config.o['workspace.foundation'] = {}
+
+                        pkg.config.o['workspace.foundation'][structKey] = data
+
+                        await this._writePackageJson(packageJsonPath, pkg)
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/PackageDescriptor'

package/caps/ProjectCatalogs.ts

@@ -0,0 +1,153 @@
+
+export async function capsule({
+    encapsulate,
+    CapsulePropertyTypes,
+    makeImportStack
+}: {
+    encapsulate: any
+    CapsulePropertyTypes: any
+    makeImportStack: any
+}) {
+    return encapsulate({
+        '#@stream44.studio/encapsulate/spine-contracts/CapsuleSpineContract.v0': {
+            '#@stream44.studio/encapsulate/structs/Capsule': {},
+            '#@stream44.studio/t44/structs/ProjectCatalogsConfig': {
+                as: '$ProjectCatalogsConfig',
+            },
+            '#': {
+                HomeRegistry: {
+                    type: CapsulePropertyTypes.Mapping,
+                    value: '@stream44.studio/t44/caps/HomeRegistry'
+                },
+                list: {
+                    type: CapsulePropertyTypes.GetterFunction,
+                    value: async function (this: any): Promise<Record<string, any>> {
+                        const catalogsConfig = await this.$ProjectCatalogsConfig.config
+                        return catalogsConfig?.catalogs || {}
+                    }
+                },
+                validate: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any): Promise<boolean> {
+                        const catalogsConfig = await this.$ProjectCatalogsConfig.config
+                        const catalogs = catalogsConfig?.catalogs
+
+                        if (!catalogs || typeof catalogs !== 'object') {
+                            return true
+                        }
+
+                        const chalk = (await import('chalk')).default
+
+                        for (const [catalogName, catalogConfig] of Object.entries(catalogs)) {
+                            if (!catalogConfig || typeof catalogConfig !== 'object') {
+                                console.log(chalk.red(`\n✗ Invalid catalog '${catalogName}': must be an object.\n`))
+                                return false
+                            }
+
+                            const fileName = catalogName.replace(/\//g, '~')
+                            const typedConfig = catalogConfig as Record<string, any>
+
+                            const existing = await this.HomeRegistry.getCatalog(fileName) || {}
+                            const now = new Date().toISOString()
+
+                            // Deep merge: config keys into existing, preserving existing nested data
+                            let changed = false
+                            for (const [key, value] of Object.entries(typedConfig)) {
+                                if (key === 'repositories' && typeof value === 'object' && typeof existing[key] === 'object') {
+                                    // Merge repositories: add missing repos, keep existing repo data
+                                    for (const [repoName, repoConfig] of Object.entries(value as Record<string, any>)) {
+                                        if (!existing[key][repoName]) {
+                                            existing[key][repoName] = repoConfig || {}
+                                            changed = true
+                                        }
+                                    }
+                                } else if (JSON.stringify(existing[key]) !== JSON.stringify(value)) {
+                                    existing[key] = value
+                                    changed = true
+                                }
+                            }
+
+                            if (changed) {
+                                existing.updatedAt = now
+                            }
+                            if (!existing.createdAt) {
+                                existing.createdAt = now
+                            }
+
+                            const filePath = await this.HomeRegistry.setCatalog(fileName, existing)
+                            if (changed) {
+                                console.log(chalk.green(`   ✓ Catalog '${catalogName}' → ${filePath}`))
+                            }
+                        }
+
+                        return true
+                    }
+                },
+                updateCatalogRepository: {
+                    type: CapsulePropertyTypes.Function,
+                    value: async function (this: any, {
+                        repoName,
+                        providerKey,
+                        providerData,
+                    }: {
+                        repoName: string
+                        providerKey: string
+                        providerData: Record<string, any>
+                    }): Promise<void> {
+                        const catalogsConfig = await this.$ProjectCatalogsConfig.config
+                        const catalogs = catalogsConfig?.catalogs
+
+                        if (!catalogs || typeof catalogs !== 'object') return
+
+                        for (const [catalogName, catalogConfig] of Object.entries(catalogs)) {
+                            const typedConfig = catalogConfig as Record<string, any>
+                            const repositories = typedConfig.repositories
+                            if (!repositories || typeof repositories !== 'object') continue
+                            if (!(repoName in repositories)) continue
+
+                            const fileName = catalogName.replace(/\//g, '~')
+                            const existing = await this.HomeRegistry.getCatalog(fileName)
+                            if (!existing) continue
+
+                            if (!existing.repositories) existing.repositories = {}
+                            if (!existing.repositories[repoName]) existing.repositories[repoName] = {}
+                            const repoEntry = existing.repositories[repoName]
+                            const now = new Date().toISOString()
+
+                            const existingEntity = repoEntry[providerKey]
+                            const entityCreatedAt = existingEntity?.createdAt || now
+
+                            // Check if data actually changed (compare without timestamps, order-independent)
+                            const { createdAt: _ec, updatedAt: _eu, ...existingData } = existingEntity || {}
+                            const stableStringify = (obj: any): string => JSON.stringify(obj, (_, v) =>
+                                v && typeof v === 'object' && !Array.isArray(v)
+                                    ? Object.keys(v).sort().reduce((o: any, k) => { o[k] = v[k]; return o }, {})
+                                    : v
+                            )
+                            const dataChanged = stableStringify(existingData) !== stableStringify(providerData)
+
+                            repoEntry[providerKey] = {
+                                ...providerData,
+                                createdAt: entityCreatedAt,
+                                updatedAt: dataChanged ? now : (existingEntity?.updatedAt || now),
+                            }
+
+                            if (!repoEntry.createdAt) repoEntry.createdAt = now
+                            if (dataChanged) {
+                                repoEntry.updatedAt = now
+                                existing.updatedAt = now
+                            }
+
+                            await this.HomeRegistry.setCatalog(fileName, existing)
+                        }
+                    }
+                },
+            }
+        }
+    }, {
+        importMeta: import.meta,
+        importStack: makeImportStack(),
+        capsuleName: capsule['#'],
+    })
+}
+capsule['#'] = '@stream44.studio/t44/caps/ProjectCatalogs'