@tokens-studio/tokenscript-schemas 0.1.2 → 0.2.0

package/src/bundler/schema-dependency-resolver.ts

@@ -10,7 +10,7 @@ import type {
   SchemaSpecification,
 } from "@/bundler/types.js";
 import { extractSchemaName, parseSchemaUri } from "@/utils/schema-uri";
-import { bundleSchemaFromDirectory } from "./bundle-schema.js";
+import { buildSchemaFromDirectory } from "./build-schema.js";
 
 export interface SchemaReference {
   slug: string;
@@ -181,7 +181,7 @@ export async function collectRequiredSchemas(
         schemasDir || process.env.SCHEMAS_DIR || join(process.cwd(), "src/schemas");
       const schemaDir = join(resolvedSchemasDir, categoryDir, slug);
 
-      spec = await bundleSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : undefined);
+      spec = await buildSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : undefined);
     } catch (error) {
       log.warn(`Failed to load schema ${slug} (${effectiveType}):`, error);
       return;
@@ -275,7 +275,7 @@ export async function collectDependencyTree(
     const schemaDir = join(resolvedSchemasDir, categoryDir, schema.slug);
 
     try {
-      const spec = await bundleSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : undefined);
+      const spec = await buildSchemaFromDirectory(schemaDir, baseUrl ? { baseUrl } : undefined);
       const requirements = extractRequirements(spec, extractOptions);
 
       // Extract just the slugs from URIs

package/src/bundler/selective-bundler.ts

@@ -5,7 +5,7 @@
 
 import { access } from "node:fs/promises";
 import { join } from "node:path";
-import { bundleSchemaFromDirectory } from "./bundle-schema.js";
+import { buildSchemaFromDirectory } from "./build-schema.js";
 import {
   collectDependencyTree,
   collectRequiredSchemasForList,
@@ -124,7 +124,7 @@ export async function bundleSelectiveSchemas(
   // Bundle type schemas
   for (const typeSlug of deps.types) {
     const schemaDir = join(schemasDir, "types", typeSlug);
-    const bundled = await bundleSchemaFromDirectory(schemaDir, { baseUrl });
+    const bundled = await buildSchemaFromDirectory(schemaDir, { baseUrl });
 
     if (bundled.type === "color") {
       const uri = `${baseUrl}/api/v1/core/${typeSlug}/0/`;
@@ -138,7 +138,7 @@ export async function bundleSelectiveSchemas(
   // Bundle function schemas
   for (const funcSlug of deps.functions) {
     const schemaDir = join(schemasDir, "functions", funcSlug);
-    const bundled = await bundleSchemaFromDirectory(schemaDir, { baseUrl });
+    const bundled = await buildSchemaFromDirectory(schemaDir, { baseUrl });
 
     if (bundled.type === "function") {
       const uri = `${baseUrl}/api/v1/function/${funcSlug}/0/`;

package/src/cli/commands/build-dir.test.ts

@@ -0,0 +1,354 @@
+import { existsSync } from "node:fs";
+import { mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
+import { buildSchemaDir } from "./build-dir.js";
+
+// Mock ulog to silence logs during tests
+vi.mock("ulog", () => {
+  const mockLogger = () => {};
+  mockLogger.error = () => {};
+  mockLogger.warn = () => {};
+  mockLogger.info = () => {};
+  mockLogger.log = () => {};
+  mockLogger.debug = () => {};
+  mockLogger.trace = () => {};
+
+  return {
+    default: () => mockLogger,
+  };
+});
+
+// Mock console.log to capture stdout
+const originalConsoleLog = console.log;
+let capturedOutput: string[] = [];
+
+function mockConsoleLog(...args: any[]) {
+  capturedOutput.push(args.join(" "));
+}
+
+describe("Build Command", () => {
+  // Test with real existing schemas
+  describe("with real schemas", () => {
+    it("should build css-color type schema", async () => {
+      const cssColorDir = join(process.cwd(), "src/schemas/types/css-color");
+
+      // Capture console output
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(cssColorDir);
+
+      // Restore console
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+      const result = JSON.parse(output);
+
+      expect(result.name).toBe("CSS");
+      expect(result.type).toBe("color");
+      expect(result.initializers).toBeDefined();
+      expect(result.conversions).toBeDefined();
+
+      // Verify scripts are inlined
+      expect(result.initializers[0].script.script).toContain("variable");
+      expect(result.conversions[0].script.script).toContain("variable");
+    });
+
+    it("should build darken function schema", async () => {
+      const darkenDir = join(process.cwd(), "src/schemas/functions/darken");
+
+      // Capture console output
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(darkenDir);
+
+      // Restore console
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+      const result = JSON.parse(output);
+
+      expect(result.name).toBe("Darken");
+      expect(result.type).toBe("function");
+      expect(result.keyword).toBe("darken");
+      expect(result.script).toBeDefined();
+      expect(result.requirements).toBeDefined();
+
+      // Verify script is inlined
+      expect(result.script.script).toContain("darken");
+      expect(result.script.script).toContain("OKLab");
+    });
+  });
+
+  describe("with custom test schemas", () => {
+    const customSchemasDir = join(process.cwd(), "test-build-schemas");
+    const customTypeDir = join(customSchemasDir, "custom-color");
+    const customFunctionDir = join(customSchemasDir, "custom-function");
+
+    beforeAll(async () => {
+      // Create custom color type schema
+      await mkdir(customTypeDir, { recursive: true });
+
+      const colorSchemaJson = {
+        name: "TestColor",
+        type: "color" as const,
+        description: "A test color type",
+        slug: "test-color",
+        schema: {
+          type: "object" as const,
+          properties: {
+            value: { type: "string" as const },
+          },
+          required: ["value"],
+        },
+        initializers: [
+          {
+            title: "Test Initializer",
+            keyword: "testcolor",
+            description: "Creates a test color",
+            script: {
+              type: "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
+              script: "./test-initializer.tokenscript",
+            },
+          },
+        ],
+        conversions: [
+          {
+            source: "$self",
+            target: "$self",
+            description: "Test conversion",
+            lossless: true,
+            script: {
+              type: "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
+              script: "./test-conversion.tokenscript",
+            },
+          },
+        ],
+      };
+
+      await writeFile(join(customTypeDir, "schema.json"), JSON.stringify(colorSchemaJson, null, 2));
+
+      const initializerScript = `// Test initializer
+variable input: List = {input};
+variable value: String = input.get(0);
+variable output: Color.TestColor;
+output.value = value;
+return output;`;
+
+      await writeFile(join(customTypeDir, "test-initializer.tokenscript"), initializerScript);
+
+      const conversionScript = `// Test conversion
+variable input: Color.TestColor = {input};
+variable output: Color.TestColor;
+output.value = input.value;
+return output;`;
+
+      await writeFile(join(customTypeDir, "test-conversion.tokenscript"), conversionScript);
+
+      // Create custom function schema
+      await mkdir(customFunctionDir, { recursive: true });
+
+      const functionSchemaJson = {
+        name: "TestFunction",
+        type: "function" as const,
+        description: "A test function",
+        keyword: "testfunc",
+        input: {
+          type: "object" as const,
+          properties: {
+            value: { type: "number" as const },
+          },
+        },
+        script: {
+          type: "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
+          script: "./test-function.tokenscript",
+        },
+        requirements: [] as string[],
+      };
+
+      await writeFile(
+        join(customFunctionDir, "schema.json"),
+        JSON.stringify(functionSchemaJson, null, 2),
+      );
+
+      const functionScript = `// Test function
+variable input: List = {input};
+variable value: Number = input.get(0);
+return value * 2;`;
+
+      await writeFile(join(customFunctionDir, "test-function.tokenscript"), functionScript);
+    });
+
+    afterAll(async () => {
+      // Clean up
+      try {
+        await rm(customSchemasDir, { recursive: true, force: true });
+      } catch {
+        // Ignore
+      }
+    });
+
+    it("should build color type schema with inlined scripts", async () => {
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(customTypeDir);
+
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+      const result = JSON.parse(output);
+
+      expect(result.name).toBe("TestColor");
+      expect(result.type).toBe("color");
+      expect(result.initializers[0].script.script).toContain("variable input: List");
+      expect(result.conversions[0].script.script).toContain("variable input: Color.TestColor");
+    });
+
+    it("should build function schema with inlined script", async () => {
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(customFunctionDir);
+
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+      const result = JSON.parse(output);
+
+      expect(result.name).toBe("TestFunction");
+      expect(result.type).toBe("function");
+      expect(result.script.script).toContain("variable input: List");
+      expect(result.script.script).toContain("return value * 2");
+    });
+
+    it("should output pretty JSON with --pretty option", async () => {
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(customTypeDir, { pretty: true });
+
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+
+      // Pretty JSON should have newlines and indentation
+      expect(output).toContain("\n");
+      expect(output).toContain("  ");
+    });
+
+    it("should output compact JSON without --pretty option", async () => {
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(customTypeDir, { pretty: false });
+
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+
+      // Compact JSON should not have newlines (except maybe trailing)
+      const lineCount = output.split("\n").length;
+      expect(lineCount).toBeLessThan(5);
+    });
+
+    it("should write to file when --output is specified", async () => {
+      const outputFile = join(customSchemasDir, "output.json");
+
+      await buildSchemaDir(customTypeDir, { output: outputFile });
+
+      expect(existsSync(outputFile)).toBe(true);
+
+      const content = await readFile(outputFile, "utf-8");
+      const result = JSON.parse(content);
+
+      expect(result.name).toBe("TestColor");
+    });
+
+    it("should write pretty JSON to file with --pretty and --output", async () => {
+      const outputFile = join(customSchemasDir, "output-pretty.json");
+
+      await buildSchemaDir(customTypeDir, { output: outputFile, pretty: true });
+
+      const content = await readFile(outputFile, "utf-8");
+
+      // Pretty JSON should have newlines and indentation
+      expect(content).toContain("\n");
+      expect(content).toContain("  ");
+    });
+  });
+
+  describe("error handling", () => {
+    it("should throw error for non-existent directory", async () => {
+      await expect(buildSchemaDir("/non-existent/directory")).rejects.toThrow(
+        /Directory not found|not found/,
+      );
+    });
+
+    it("should throw error for directory without schema.json", async () => {
+      const emptyDir = join(process.cwd(), "test-empty-dir");
+
+      await mkdir(emptyDir, { recursive: true });
+
+      try {
+        await expect(buildSchemaDir(emptyDir)).rejects.toThrow(/schema.json not found/);
+      } finally {
+        await rm(emptyDir, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe("path resolution", () => {
+    const testSchemasDir = join(process.cwd(), "test-path-schemas");
+    const testSchemaDir = join(testSchemasDir, "test-schema");
+
+    beforeAll(async () => {
+      await mkdir(testSchemaDir, { recursive: true });
+
+      const schemaJson = {
+        name: "PathTest",
+        type: "color" as const,
+        description: "Path test schema",
+        slug: "path-test",
+        schema: {
+          type: "object" as const,
+          properties: {
+            value: { type: "string" as const },
+          },
+          required: ["value"],
+        },
+        initializers: [] as any[],
+        conversions: [] as any[],
+      };
+
+      await writeFile(join(testSchemaDir, "schema.json"), JSON.stringify(schemaJson, null, 2));
+    });
+
+    afterAll(async () => {
+      try {
+        await rm(testSchemasDir, { recursive: true, force: true });
+      } catch {
+        // Ignore
+      }
+    });
+
+    it("should resolve relative paths from current working directory", async () => {
+      // Use a relative path
+      const relativePath = "test-path-schemas/test-schema";
+
+      capturedOutput = [];
+      console.log = mockConsoleLog;
+
+      await buildSchemaDir(relativePath);
+
+      console.log = originalConsoleLog;
+
+      const output = capturedOutput[0];
+      const result = JSON.parse(output);
+
+      expect(result.name).toBe("PathTest");
+    });
+  });
+});

package/src/cli/commands/build-dir.ts

@@ -0,0 +1,90 @@
+/**
+ * Build command - Build individual schema directories
+ */
+
+/// <reference types="../../../types/ulog" />
+
+import { existsSync } from "node:fs";
+import { mkdir, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import anylogger from "ulog";
+import { buildSchemaFromDirectory } from "@/bundler/build-schema.js";
+
+const log = anylogger("build-dir");
+
+export interface BuildDirOptions {
+  output?: string;
+  pretty?: boolean;
+}
+
+/**
+ * Build a schema from a directory containing schema.json
+ */
+export async function buildSchemaDir(
+  schemaDir: string,
+  options: BuildDirOptions = {},
+): Promise<void> {
+  const resolvedDir = resolveSchemaDir(schemaDir);
+
+  if (!existsSync(resolvedDir)) {
+    throw new Error(`Directory not found: ${resolvedDir}`);
+  }
+
+  const schemaJsonPath = join(resolvedDir, "schema.json");
+  if (!existsSync(schemaJsonPath)) {
+    throw new Error(`schema.json not found in: ${resolvedDir}`);
+  }
+
+  log.info(`Building schema from: ${resolvedDir}`);
+
+  // Build the schema using shared bundler logic
+  const schema = await buildSchemaFromDirectory(resolvedDir);
+
+  // Generate output
+  const output = options.pretty ? JSON.stringify(schema, null, 2) : JSON.stringify(schema);
+
+  // Write to stdout or file
+  if (options.output) {
+    await mkdir(dirname(options.output), { recursive: true });
+    await writeFile(options.output, output, "utf-8");
+    log.info(`Output written to: ${options.output}`);
+    console.log(`✓ Built ${schema.type}:${schema.name} → ${options.output}`);
+  } else {
+    console.log(output);
+  }
+}
+
+/**
+ * Resolve schema directory - handles relative paths
+ */
+function resolveSchemaDir(schemaDir: string): string {
+  // If absolute path, use as-is
+  if (existsSync(schemaDir)) {
+    return schemaDir;
+  }
+
+  // Try relative to current working directory
+  const cwd = process.cwd();
+  const fromCwd = join(cwd, schemaDir);
+  if (existsSync(fromCwd)) {
+    return fromCwd;
+  }
+
+  // Return as-is and let error handling catch it
+  return schemaDir;
+}
+
+/**
+ * CLI action handler for build command
+ */
+export async function handleBuildCommand(
+  schemaDir: string,
+  options: BuildDirOptions = {},
+): Promise<void> {
+  try {
+    await buildSchemaDir(schemaDir, options);
+  } catch (error) {
+    log.error("Build failed:", error);
+    throw error;
+  }
+}

package/src/cli/commands/bundle.test.ts

@@ -1,4 +1,6 @@
-import { describe, expect, it, vi } from "vitest";
+import { mkdir, rm, writeFile } from "node:fs/promises";
+import { join } from "node:path";
+import { afterAll, beforeAll, describe, expect, it, vi } from "vitest";
 import { expandPresetSchemas } from "@/bundler/presets/index.js";
 import { bundleSchemas } from "./bundle.js";
 
@@ -88,4 +90,96 @@ describe("Bundle Command", () => {
       warnSpy.mockRestore();
     });
   });
+
+  describe("Custom Schema Directory", () => {
+    const customSchemasDir = join(process.cwd(), "test-custom-schemas");
+    const customTypeDir = join(customSchemasDir, "types", "custom-color");
+
+    beforeAll(async () => {
+      // Create custom schema directory structure
+      await mkdir(customTypeDir, { recursive: true });
+
+      // Create a custom schema.json
+      const schemaJson = {
+        name: "CustomColor",
+        type: "color" as const,
+        description: "A custom color type for testing",
+        slug: "custom-color",
+        schema: {
+          type: "object" as const,
+          properties: {
+            x: { type: "number" as const },
+            y: { type: "number" as const },
+          },
+          required: ["x", "y"],
+          additionalProperties: false,
+        },
+        initializers: [
+          {
+            keyword: "customcolor",
+            script: {
+              type: "https://schema.tokenscript.dev.gcp.tokens.studio/api/v1/core/tokenscript/0/",
+              script: "./custom-initializer.tokenscript",
+            },
+          },
+        ],
+        conversions: [] as any[],
+      };
+
+      await writeFile(
+        join(customTypeDir, "schema.json"),
+        JSON.stringify(schemaJson, null, 2),
+        "utf-8",
+      );
+
+      // Create a custom initializer script
+      const initializerScript = `
+variable x_val: Number = args.get(0);
+variable y_val: Number = args.get(1);
+variable result: Color.CustomColor = (x: x_val, y: y_val);
+result
+      `.trim();
+
+      await writeFile(join(customTypeDir, "custom-initializer.tokenscript"), initializerScript);
+    });
+
+    afterAll(async () => {
+      // Clean up custom schemas directory
+      try {
+        await rm(customSchemasDir, { recursive: true, force: true });
+      } catch {
+        // Ignore if directory doesn't exist
+      }
+    });
+
+    it("should bundle schemas from custom directory", async () => {
+      const result = await bundleSchemas(["type:custom-color"], customSchemasDir);
+
+      expect(result.output).toContain("SCHEMAS");
+      expect(result.output).toContain("custom-color");
+      expect(result.metadata.requestedSchemas).toEqual(["type:custom-color"]);
+      expect(result.metadata.resolvedDependencies).toContain("custom-color");
+    });
+
+    it("should include custom schema in output", async () => {
+      const result = await bundleSchemas(["custom-color"], customSchemasDir);
+
+      // Verify the output contains the custom schema definition
+      expect(result.output).toContain("CustomColor");
+      expect(result.output).toContain("customcolor");
+      expect(result.output).toContain("A custom color type for testing");
+    });
+
+    it("should use custom directory metadata in output", async () => {
+      const cliArgs = ["type:custom-color", "--schemas-dir", customSchemasDir];
+      const result = await bundleSchemas(["type:custom-color"], customSchemasDir, cliArgs);
+
+      expect(result.metadata.generatedBy).toContain("--schemas-dir");
+      expect(result.metadata.generatedBy).toContain(customSchemasDir);
+    });
+
+    it("should fail gracefully when schema not found in custom directory", async () => {
+      await expect(bundleSchemas(["type:nonexistent-schema"], customSchemasDir)).rejects.toThrow();
+    });
+  });
 });

package/src/cli/commands/bundle.ts

@@ -4,6 +4,7 @@
 
 /// <reference types="../../../types/ulog" />
 
+import { existsSync } from "node:fs";
 import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -20,6 +21,7 @@ export interface BundleOptions {
   config?: string;
   output?: string;
   dryRun?: boolean;
+  schemasDir?: string; // Comma-separated list of custom schema directories
 }
 
 /**
@@ -118,27 +120,23 @@ function findSchemasDir(): string {
   const __filename = fileURLToPath(import.meta.url);
   const __dirname = dirname(__filename);
 
-  // From compiled dist/cli/index.js (bundled) to src/schemas
+  // From compiled dist/cli/commands/bundle.js to src/schemas
   const fromDist = join(__dirname, "../../src/schemas");
 
   // From source src/cli/commands/bundle.ts to src/schemas (for tests/dev)
   const fromSource = join(__dirname, "../../schemas");
 
-  // Try to detect which one exists (check dist first for installed package)
-  try {
-    const fs = require("node:fs");
-    if (fs.existsSync(fromDist)) {
-      return fromDist;
-    }
-    if (fs.existsSync(fromSource)) {
-      return fromSource;
-    }
-  } catch {
-    // If fs checks fail, default to dist structure
+  // Check source first (for development), then dist (for installed package)
+  if (existsSync(fromSource)) {
+    return fromSource;
+  }
+
+  if (existsSync(fromDist)) {
+    return fromDist;
   }
 
-  // Default to dist structure (for installed package)
-  return fromDist;
+  // Default to source structure (for development)
+  return fromSource;
 }
 
 /**
@@ -227,11 +225,20 @@ export async function handleBundleCommand(
     if (options.dryRun) {
       cliArgs.push("--dry-run");
     }
+    if (options.schemasDir) {
+      cliArgs.push("--schemas-dir", options.schemasDir);
+    }
+
+    // Use custom schema directory if provided
+    const customSchemasDir = options.schemasDir;
+    if (customSchemasDir) {
+      log.info(`Using custom schema directory: ${customSchemasDir}`);
+    }
 
     // Bundle schemas
     const { output, metadata, dependencyTree } = await bundleSchemas(
       configSchemas,
-      undefined,
+      customSchemasDir,
       cliArgs,
     );