@figulus/schema 0.4.0-alpha-dev → 0.5.0-alpha-dev-1

package/src/registry/metadata.ts

@@ -0,0 +1,181 @@
+import z, { ZodObject, ZodRawShape } from "zod";
+import { extendZodWithOpenApi } from "@asteasolutions/zod-to-openapi";
+import { parseLicenseId } from "zod-spdx";
+import { JsonSchemaSchema } from "./json-schema.js";
+
+extendZodWithOpenApi(z);
+
+const ipfsSchema = z.string().startsWith("ipfs:");
+const urlLike = z.union([z.url(), ipfsSchema]);
+
+export const namespaceMetadataEditorEntrySchema = z.object({
+  username: z.string(),
+  // Cannot exceed namespace push limit -- use this for more granular control, otherwise first-in-first-served
+  pushLimit: z
+    .discriminatedUnion("unit", [
+      z.object({
+        unit: z.literal("daily"),
+        value: z.int(),
+      }),
+      z.object({
+        unit: z.literal("weekly"),
+        value: z.int(),
+      }),
+    ])
+    .optional(),
+});
+export type NamespaceMetadataEditorEntry = z.infer<
+  typeof namespaceMetadataEditorEntrySchema
+>;
+
+export const namespaceMetadataSchema = z
+  .object({
+    owner: z.object({
+      username: z.string(),
+    }),
+    editors: namespaceMetadataEditorEntrySchema.array().min(1).max(5),
+  })
+  .refine(
+    (data) => data.editors.some((e) => e.username === data.owner.username),
+    { message: "editors must include the owner", path: ["editors"] },
+  )
+  .openapi("NamespaceMetadata");
+export type NamespaceMetadata = z.infer<typeof namespaceMetadataSchema>;
+
+export const namespaceVerificationsSchema = z
+  .object({
+    namespace: z.string(),
+    verification: z.enum(["figulus-official", "software-official"]),
+  })
+  .array().openapi("NamespaceVerifications");
+export type NamespaceVerifications = z.infer<
+  typeof namespaceVerificationsSchema
+>;
+
+// If not included in this list, namespace is limited to default push limit from settings
+// Automated systems shouldn't modify this file -- it must be manually edited by repo owner under special circumstances
+export const pushLimitOverridesSchema = z
+  .object({
+    namespace: z.string(),
+    // Allows for soft-banning/suspension/archival, or increased limits for special accounts
+    pushLimit: z.discriminatedUnion("unit", [
+      z.object({
+        unit: z.literal("daily"),
+        value: z.int(),
+      }),
+      z.object({
+        unit: z.literal("weekly"),
+        value: z.int(),
+      }),
+    ]),
+  })
+  .array().openapi("PushLimitOverrides");
+export type PushLimitOverrides = z.infer<typeof pushLimitOverridesSchema>;
+
+export const figEntityMetadataBaseSchema = z.object({
+  title: z.string(),
+  description: z.string(),
+  icon: z
+    .object({
+      svg: urlLike,
+      emojiFallback: z.emoji().optional(),
+      aspectRatio: z
+        .object({
+          w: z.number(),
+          h: z.number(),
+        })
+        .optional(),
+    })
+    .optional(),
+  tags: z.array(z.string()).optional(),
+  author: z.union([
+    z.string(),
+    z.string().array(),
+    z
+      .object({
+        type: z.enum([
+          "software-author",
+          "software-maintainer",
+          "fig-author",
+          "fig-maintainer",
+        ]),
+        name: z.string(),
+        url: z.url().optional(),
+      })
+      .array(),
+  ]),
+  license: z.union([
+    z.string().transform((s, ctx) => {
+      const result = parseLicenseId(s, { caseSensitive: false });
+      if (!result.success) {
+        ctx.addIssue({
+          code: "custom",
+          message: `Invalid SPDX license ID: ${s}`,
+        });
+        return z.NEVER;
+      }
+      return result.data;
+    }),
+    z.object({
+      name: z.string(),
+      url: z.url().optional(),
+    }),
+  ]),
+  softwareSource: z
+    .union([z.url(), z.url().array()])
+    .optional(),
+}).openapi("FigEntityMetadataBase");
+
+const hexSchema = z.string().regex(/[0-9A-Fa-f]+/);
+
+export const blobSchema = z.object({
+  contentHash: hexSchema,
+  ipfsCid: z.string().optional(),
+}).openapi("Blob");
+
+export const variantSchema = z.object({
+  blob: blobSchema,
+  tag: z.string().optional(),
+  createdAt: z.iso.datetime().default(new Date().toISOString()),
+  updatedAt: z.iso.datetime().default(new Date().toISOString()),
+}).openapi("Variant");
+
+export const parserVariantSchema = variantSchema.extend({
+  // Represents the parsed JSON schema — allows any object structure since JsonSchemaSchema is
+  // recursively self-referential and cannot be fully represented in OpenAPI
+  parsedShape: z.union([z.record(z.string(), z.any()), z.boolean()]).optional(),
+}).openapi("ParserVariant");
+
+// Ensure all tags are unique
+function uniqueArray<T extends ZodObject<ZodRawShape>>(schema: T) {
+  return schema.array().refine((items) => {
+    const tags = items
+      .map((item) => (item as { tag?: string }).tag)
+      .filter((item) => item !== undefined);
+    return new Set(tags).size === tags.length;
+  });
+}
+
+export const figParserMetadataSchema = figEntityMetadataBaseSchema.extend({
+  variants: uniqueArray(parserVariantSchema),
+}).openapi("FigParserMetadata");
+export type FigParserMetadata = z.infer<typeof figParserMetadataSchema>;
+
+export const figSpecMetadataSchema = figEntityMetadataBaseSchema.extend({
+  variants: uniqueArray(variantSchema),
+}).openapi("FigSpecMetadata");
+export type FigSpecMetadata = z.infer<typeof figSpecMetadataSchema>;
+
+export const figStackMetadataSchema = figEntityMetadataBaseSchema.extend({
+  variants: uniqueArray(variantSchema),
+}).openapi("FigStackMetadata");
+export type FigStackMetadata = z.infer<typeof figStackMetadataSchema>;
+
+export type EntityType = "spec" | "stack" | "parser";
+export type FigEntityMetadata<Type extends EntityType> = Type extends "spec"
+  ? FigSpecMetadata
+  : Type extends "stack"
+    ? FigStackMetadata
+    : Type extends "parser"
+      ? FigParserMetadata
+      : null;

package/tests/figspec.test.ts

@@ -9,7 +9,7 @@ import {
   installGroupSchema,
   onExitBehaviorSchema,
   executeMainCmdSchema,
-} from '../src/figspec.js';
+} from '../src/index.js';
 
 // ---------------------------------------------------------------------------
 // Helpers

package/tests/schemas.test.ts

@@ -8,17 +8,17 @@
 
 import { describe, it, expect } from 'vitest';
 import {
-  RunRequestSchema,
-  JobStatusSchema,
-  CreateSessionRequestSchema,
-  SyncFileRequestSchema,
+  runRequestSchema,
+  jobStatusSchema,
+  createSessionRequestSchema,
+  syncFileRequestSchema,
 } from '../src/index.js';
 
 describe('Zod Schema Validation', () => {
   describe('RunRequest Schema', () => {
     it('should validate a minimal valid request', () => {
       const valid = { job_id: 'job-001', image: 'node:20-alpine' };
-      expect(() => RunRequestSchema.parse(valid)).not.toThrow();
+      expect(() => runRequestSchema.parse(valid)).not.toThrow();
     });
 
     it('should validate a fully populated request', () => {
@@ -35,37 +35,37 @@ describe('Zod Schema Validation', () => {
         network_mode: 'bridge',
         ports: [{ container: 3000, host: 8080 }],
       };
-      expect(() => RunRequestSchema.parse(valid)).not.toThrow();
+      expect(() => runRequestSchema.parse(valid)).not.toThrow();
     });
 
     it('should reject missing job_id', () => {
       const invalid = { image: 'node:20-alpine' };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject missing image', () => {
       const invalid = { job_id: 'job-001' };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject empty job_id', () => {
       const invalid = { job_id: '', image: 'node:20-alpine' };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject negative timeout', () => {
       const invalid = { job_id: 'job-001', image: 'node:20', timeout: -1 };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject timeout exceeding max', () => {
       const invalid = { job_id: 'job-001', image: 'node:20', timeout: 99999 };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject non-integer timeout', () => {
       const invalid = { job_id: 'job-001', image: 'node:20', timeout: 30.5 };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject invalid port number', () => {
@@ -74,7 +74,7 @@ describe('Zod Schema Validation', () => {
         image: 'node:20',
         ports: [{ container: 99999 }],
       };
-      expect(() => RunRequestSchema.parse(invalid)).toThrow();
+      expect(() => runRequestSchema.parse(invalid)).toThrow();
     });
   });
 
@@ -82,21 +82,21 @@ describe('Zod Schema Validation', () => {
     it('should accept all valid status values', () => {
       const validValues = ['pending', 'running', 'completed', 'failed', 'timeout', 'awaiting_cleanup'];
       for (const val of validValues) {
-        expect(() => JobStatusSchema.parse(val)).not.toThrow();
+        expect(() => jobStatusSchema.parse(val)).not.toThrow();
       }
     });
 
     it('should reject invalid status values', () => {
-      expect(() => JobStatusSchema.parse('cancelled')).toThrow();
-      expect(() => JobStatusSchema.parse('done')).toThrow();
-      expect(() => JobStatusSchema.parse('')).toThrow();
+      expect(() => jobStatusSchema.parse('cancelled')).toThrow();
+      expect(() => jobStatusSchema.parse('done')).toThrow();
+      expect(() => jobStatusSchema.parse('')).toThrow();
     });
   });
 
   describe('CreateSessionRequest Schema', () => {
     it('should validate a minimal valid request', () => {
       const valid = { image_tag: 'localhost:5000/figulus:sha256-abc123' };
-      expect(() => CreateSessionRequestSchema.parse(valid)).not.toThrow();
+      expect(() => createSessionRequestSchema.parse(valid)).not.toThrow();
     });
 
     it('should validate a request with config', () => {
@@ -110,27 +110,27 @@ describe('Zod Schema Validation', () => {
           ports: [{ container: 3000 }],
         },
       };
-      expect(() => CreateSessionRequestSchema.parse(valid)).not.toThrow();
+      expect(() => createSessionRequestSchema.parse(valid)).not.toThrow();
     });
 
     it('should reject missing image_tag', () => {
       const invalid = { ttl: 600 };
-      expect(() => CreateSessionRequestSchema.parse(invalid)).toThrow();
+      expect(() => createSessionRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject empty image_tag', () => {
       const invalid = { image_tag: '' };
-      expect(() => CreateSessionRequestSchema.parse(invalid)).toThrow();
+      expect(() => createSessionRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject negative ttl', () => {
       const invalid = { image_tag: 'some-image:latest', ttl: -1 };
-      expect(() => CreateSessionRequestSchema.parse(invalid)).toThrow();
+      expect(() => createSessionRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject non-integer ttl', () => {
       const invalid = { image_tag: 'some-image:latest', ttl: 60.5 };
-      expect(() => CreateSessionRequestSchema.parse(invalid)).toThrow();
+      expect(() => createSessionRequestSchema.parse(invalid)).toThrow();
     });
   });
 
@@ -141,7 +141,7 @@ describe('Zod Schema Validation', () => {
         content: 'Y29uc29sZS5sb2coImhlbGxvIik=',
         encoding: 'base64',
       };
-      expect(() => SyncFileRequestSchema.parse(valid)).not.toThrow();
+      expect(() => syncFileRequestSchema.parse(valid)).not.toThrow();
     });
 
     it('should validate a valid utf8 request', () => {
@@ -150,38 +150,38 @@ describe('Zod Schema Validation', () => {
         content: 'console.log("hello")',
         encoding: 'utf8',
       };
-      expect(() => SyncFileRequestSchema.parse(valid)).not.toThrow();
+      expect(() => syncFileRequestSchema.parse(valid)).not.toThrow();
     });
 
     it('should default encoding to base64 when omitted', () => {
       const input = { targetPath: '/app/src/index.ts', content: 'abc' };
-      const result = SyncFileRequestSchema.parse(input);
+      const result = syncFileRequestSchema.parse(input);
       expect(result.encoding).toBe('base64');
     });
 
     it('should reject missing targetPath', () => {
       const invalid = { content: 'abc', encoding: 'base64' };
-      expect(() => SyncFileRequestSchema.parse(invalid)).toThrow();
+      expect(() => syncFileRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject empty targetPath', () => {
       const invalid = { targetPath: '', content: 'abc', encoding: 'base64' };
-      expect(() => SyncFileRequestSchema.parse(invalid)).toThrow();
+      expect(() => syncFileRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject missing content', () => {
       const invalid = { targetPath: '/app/file.ts', encoding: 'base64' };
-      expect(() => SyncFileRequestSchema.parse(invalid)).toThrow();
+      expect(() => syncFileRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject empty content', () => {
       const invalid = { targetPath: '/app/file.ts', content: '', encoding: 'base64' };
-      expect(() => SyncFileRequestSchema.parse(invalid)).toThrow();
+      expect(() => syncFileRequestSchema.parse(invalid)).toThrow();
     });
 
     it('should reject invalid encoding value', () => {
       const invalid = { targetPath: '/app/file.ts', content: 'abc', encoding: 'hex' };
-      expect(() => SyncFileRequestSchema.parse(invalid)).toThrow();
+      expect(() => syncFileRequestSchema.parse(invalid)).toThrow();
     });
   });
 });