Schema in code #1207 + did:ad:frozen #1208

browser/cli/src/commands/schema.test.ts

@@ -0,0 +1,85 @@
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import path from 'node:path';
+import { afterEach, describe, expect, it, vi } from 'vitest';
+import { Agent } from '@tomic/lib';
+
+const originalCwd = process.cwd();
+
+describe('schema command', () => {
+  afterEach(() => {
+    process.chdir(originalCwd);
+    vi.restoreAllMocks();
+  });
+
+  it('registers a code schema and generates ontology bindings from the same Store', async () => {
+    vi.spyOn(console, 'log').mockImplementation(() => undefined);
+
+    const dir = await mkdtemp(path.join(tmpdir(), 'atomic-schema-cli-'));
+    const keys = await Agent.generateKeyPair();
+    const agentSecret = Agent.buildSecret(
+      keys.privateKey,
+      `did:ad:agent:${keys.publicKey}`,
+    );
+
+    await writeFile(
+      path.join(dir, 'atomic.config.json'),
+      JSON.stringify(
+        {
+          outputFolder: './src/ontologies',
+          ontologies: [],
+          agentSecret,
+          _ISLIB_: false,
+        },
+        null,
+        2,
+      ),
+    );
+    await writeFile(
+      path.join(dir, 'todo-schema.mjs'),
+      `export default {
+        name: 'TodoApp',
+        version: '1.0.0',
+        classes: {
+          todo: {
+            type: 'object',
+            required: ['title'],
+            properties: {
+              title: { type: 'string', description: 'Task title' },
+              done: { type: 'boolean' }
+            }
+          }
+        }
+      };`,
+    );
+
+    process.chdir(dir);
+
+    const { schemaCommand } = await import('./schema.js');
+    await schemaCommand(['./todo-schema.mjs', '--local', '--generate', '--lock']);
+
+    const generated = await readFile(
+      path.join(dir, 'src/ontologies/todoApp.ts'),
+      'utf8',
+    );
+    const index = await readFile(
+      path.join(dir, 'src/ontologies/index.ts'),
+      'utf8',
+    );
+
+    expect(generated).toContain('export const todoapp');
+    expect(generated).toContain('classes:');
+    expect(generated).toContain('properties:');
+    expect(generated).toContain('interface PropTypeMapping');
+    expect(generated).toContain('did:ad:');
+    expect(index).toContain("from './todoapp.js'");
+
+    // The committed, self-verifying lockfile is written and verifies.
+    const { verifySchemaLock } = await import('@tomic/lib');
+    const lock = JSON.parse(
+      await readFile(path.join(dir, 'src/ontologies/TodoApp.schema.lock.json'), 'utf8'),
+    );
+    expect(verifySchemaLock(lock)).toEqual({ ok: true, errors: [] });
+    expect(lock.ontology).toMatch(/^did:ad:frozen:[0-9a-f]{64}$/);
+  });
+});

browser/cli/src/commands/schema.ts

@@ -0,0 +1,249 @@
+/* eslint-disable no-console */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { pathToFileURL } from 'node:url';
+import chalk from 'chalk';
+import {
+  resolveConfig as prettierResolveConfig,
+  format as prettierFormat,
+} from 'prettier';
+import {
+  buildSchemaLock,
+  verifySchemaLock,
+  type DefinedSchema,
+  type AtomicSchemaPackage,
+  type RegisteredSchema,
+} from '@tomic/lib';
+import { createConfiguredStore } from '../store.js';
+import { atomicConfig } from '../config.js';
+import { generateOntology } from '../generateOntology.js';
+import { PropertyRecord } from '../PropertyRecord.js';
+import { generateExternals } from '../generateExternals.js';
+import { generateIndex } from '../generateIndex.js';
+
+type SchemaModule = Record<string, unknown>;
+type SchemaInput = DefinedSchema | AtomicSchemaPackage;
+
+interface SchemaCommandOptions {
+  exportName: string;
+  save: boolean;
+  addToConfig: boolean;
+  generateBindings: boolean;
+  lock: boolean;
+}
+
+export const schemaCommand = async (args: string[]) => {
+  const [schemaPath, ...rest] = args;
+
+  if (!schemaPath) {
+    console.error(
+      chalk.red('ERROR: Missing schema module path.'),
+      '\nUsage: ad-generate schema ./schema.js [--export todoSchema] [--local] [--generate]',
+    );
+    process.exit(1);
+  }
+
+  const opts = parseOptions(rest);
+  const schema = await loadSchema(schemaPath, opts.exportName);
+  const store = await createConfiguredStore();
+
+  if (opts.save) {
+    store.setServerConnected(true);
+  }
+
+  const registered = await store.registerSchema(schema, { save: opts.save });
+
+  if (opts.addToConfig) {
+    await addOntologyToConfig(registered.ontology.subject);
+  }
+
+  if (opts.generateBindings) {
+    await writeOntologyBindings(registered, store);
+  }
+
+  if (opts.lock) {
+    await writeSchemaLock(schema);
+  }
+
+  printRegisteredSchema(registered, opts.save);
+};
+
+async function writeSchemaLock(schema: SchemaInput): Promise<void> {
+  const lock = buildSchemaLock(schema);
+  const verification = verifySchemaLock(lock);
+
+  if (!verification.ok) {
+    throw new Error(
+      `Refusing to write an invalid schema lock:\n${verification.errors.join('\n')}`,
+    );
+  }
+
+  const outputFolder = path.resolve(process.cwd(), atomicConfig.outputFolder);
+  const filePath = path.join(outputFolder, `${lock.name}.schema.lock.json`);
+  await fs.mkdir(outputFolder, { recursive: true });
+  await fs.writeFile(filePath, `${JSON.stringify(lock, null, 2)}\n`);
+
+  console.log(chalk.blue('Wrote lockfile'), chalk.cyan(filePath));
+}
+
+function parseOptions(args: string[]): SchemaCommandOptions {
+  let exportName = 'default';
+  let save = true;
+  let addToConfig = false;
+  let generateBindings = false;
+  let lock = false;
+
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+
+    if (arg === '--export' || arg === '-e') {
+      exportName = args[i + 1];
+      i++;
+      continue;
+    }
+
+    if (arg === '--local') {
+      save = false;
+      continue;
+    }
+
+    if (arg === '--add-to-config') {
+      addToConfig = true;
+      continue;
+    }
+
+    if (arg === '--generate') {
+      generateBindings = true;
+      continue;
+    }
+
+    if (arg === '--lock') {
+      lock = true;
+      continue;
+    }
+
+    throw new Error(`Unknown schema command option: ${arg}`);
+  }
+
+  if (!exportName) {
+    throw new Error('Missing value for --export');
+  }
+
+  return { exportName, save, addToConfig, generateBindings, lock };
+}
+
+async function loadSchema(
+  schemaPath: string,
+  exportName: string,
+): Promise<SchemaInput> {
+  const absolutePath = path.resolve(process.cwd(), schemaPath);
+  const moduleUrl = pathToFileURL(absolutePath).href;
+  const module = (await import(moduleUrl)) as SchemaModule;
+  const value = module[exportName];
+
+  if (!isSchemaInput(value)) {
+    throw new Error(
+      `Export ${exportName} from ${schemaPath} is not a defineSchema() result or schema package.`,
+    );
+  }
+
+  return value;
+}
+
+function isSchemaInput(value: unknown): value is SchemaInput {
+  if (typeof value !== 'object' || value === null) {
+    return false;
+  }
+
+  if ('schemaHash' in value && 'normalized' in value) {
+    return true;
+  }
+
+  return 'name' in value && 'classes' in value;
+}
+
+function printRegisteredSchema(
+  registered: RegisteredSchema,
+  saved: boolean,
+): void {
+  console.log(chalk.green(saved ? 'Published schema' : 'Registered schema'));
+  console.log(`${chalk.blue('Ontology:')} ${registered.ontology.subject}`);
+  console.log(`${chalk.blue('Hash:')} ${registered.model.ontology.schemaHash}`);
+  console.log(
+    `${chalk.blue('Classes:')} ${Object.keys(registered.classes).length}`,
+  );
+  console.log(
+    `${chalk.blue('Properties:')} ${Object.keys(registered.properties).length}`,
+  );
+}
+
+async function addOntologyToConfig(subject: string): Promise<void> {
+  const configPath = path.resolve(process.cwd(), './atomic.config.json');
+  const raw = await fs.readFile(configPath, 'utf8');
+  const config = JSON.parse(raw) as { ontologies?: string[] };
+  const ontologies = config.ontologies ?? [];
+
+  if (!ontologies.includes(subject)) {
+    config.ontologies = [...ontologies, subject];
+    await fs.writeFile(configPath, `${JSON.stringify(config, null, 2)}\n`);
+  }
+
+  console.log(`${chalk.blue('Config:')} added ${subject}`);
+}
+
+async function writeOntologyBindings(
+  registered: RegisteredSchema,
+  store: Awaited<ReturnType<typeof createConfiguredStore>>,
+): Promise<void> {
+  const propertyRecord = new PropertyRecord();
+  const ontology = await generateOntology(
+    registered.ontology.subject,
+    propertyRecord,
+    store,
+  );
+
+  await writeGeneratedFile(ontology);
+
+  const missingProps = propertyRecord.getMissingProperties();
+
+  if (missingProps.length > 0) {
+    const externalsContent = await generateExternals(missingProps, store);
+    await writeGeneratedFile({
+      filename: 'externals.ts',
+      content: externalsContent,
+    });
+  }
+
+  await writeGeneratedFile(
+    generateIndex(
+      [registered.ontology.subject],
+      missingProps.length > 0,
+      store,
+    ),
+  );
+}
+
+async function writeGeneratedFile({
+  filename,
+  content,
+}: {
+  filename: string;
+  content: string;
+}): Promise<void> {
+  const outputFolder = path.resolve(process.cwd(), atomicConfig.outputFolder);
+  const filePath = path.join(outputFolder, filename);
+  await fs.mkdir(outputFolder, { recursive: true });
+
+  let formatted = content;
+  const prettierConfig = await prettierResolveConfig(filePath);
+
+  if (prettierConfig) {
+    formatted = await prettierFormat(content, {
+      ...prettierConfig,
+      parser: 'typescript',
+    });
+  }
+
+  await fs.writeFile(filePath, formatted);
+  console.log(chalk.blue('Wrote to'), chalk.cyan(filePath));
+}

browser/cli/src/config.ts

@@ -20,6 +20,8 @@ export interface AtomicConfig {
    * If left empty the public agent is used.
    */
   agentSecret?: string;
+  /** Server used for relative subjects and publishing code-first schemas. */
+  serverUrl?: string;
   /** The list of subjects of your ontologies */
 
   ontologies: string[];

browser/cli/src/generateBaseObject.ts

@@ -1,4 +1,4 @@
-import { Resource, type Core, core } from '@tomic/lib';
+import { Resource, type Core, core, type Store } from '@tomic/lib';
 import { store } from './store.js';
 import { camelCaseify, dedupe } from './utils.js';
 import chalk from 'chalk';
@@ -13,6 +13,7 @@ type BaseObject = {
 
 export const generateBaseObject = async (
   ontology: Resource<Core.Ontology>,
+  activeStore: Store = store,
 ): Promise<[string, ReverseMapping]> => {
   if (ontology.error) {
     throw ontology.error;
@@ -23,9 +24,9 @@ export const generateBaseObject = async (
   const name = camelCaseify(ontology.props.shortname);
 
   const baseObj = {
-    classes: await listToObj(classes, 'classes'),
-    properties: await listToObj(properties, 'properties'),
-    __classDefs: await createClassDefs(classes),
+    classes: await listToObj(classes, 'classes', activeStore),
+    properties: await listToObj(properties, 'properties', activeStore),
+    __classDefs: await createClassDefs(classes, activeStore),
   };
 
   const objStr = `export const ${name} = {
@@ -40,10 +41,11 @@ export const generateBaseObject = async (
 const listToObj = async (
   list: string[],
   type: string,
+  activeStore: Store,
 ): Promise<Record<string, string>> => {
   const entries = await Promise.all(
     list.map(async subject => {
-      const resource = await store.getResource(subject);
+      const resource = await activeStore.getResource(subject);
 
       return [camelCaseify(resource.get(core.properties.shortname)), subject];
     }),
@@ -76,9 +78,10 @@ const listToObj = async (
 
 const createClassDefs = async (
   classes: string[],
+  activeStore: Store,
 ): Promise<Record<string, string[]>> => {
   const classResources = await Promise.all(
-    classes.map(async c => await store.getResource(c)),
+    classes.map(async c => await activeStore.getResource(c)),
   );
 
   const entries = classResources.map(resource => {