@peers-app/peers-sdk 0.14.0 → 0.15.0

package/dist/data/orm/types.js

@@ -11,23 +11,23 @@ function fieldsToSchema(fields, codeSchema) {
         const { name, description, type, isArray, defaultValue, optional } = argSchema;
         let propertyType;
         switch (type) {
-            case 'id':
-                propertyType = zod_1.z.string().refine((id => (0, utils_1.isid)(id)), { message: 'Invalid id' });
+            case "id":
+                propertyType = zod_1.z.string().refine((id) => (0, utils_1.isid)(id), { message: "Invalid id" });
                 propertyType._def._fieldType = field_type_1.FieldType.id;
                 break;
-            case 'string':
+            case "string":
                 propertyType = zod_1.z.string();
                 break;
-            case 'number':
+            case "number":
                 propertyType = zod_1.z.number();
                 break;
-            case 'boolean':
+            case "boolean":
                 propertyType = zod_1.z.boolean();
                 break;
-            case 'Date':
+            case "Date":
                 propertyType = zod_1.z.date();
                 break;
-            case 'object':
+            case "object":
                 propertyType = zod_1.z.object({});
                 break;
             default:
@@ -39,13 +39,13 @@ function fieldsToSchema(fields, codeSchema) {
         if (optional) {
             propertyType = propertyType.optional();
         }
-        if (defaultValue) {
-            // @ts-ignore
+        if (defaultValue !== undefined) {
             propertyType = propertyType.default(defaultValue);
         }
-        propertyType = propertyType.describe(description);
-        if (codeSchema?.shape?.[name]) {
-            propertyType = zod_1.z.intersection(propertyType, codeSchema.shape[name]);
+        propertyType = propertyType.describe(description ?? "");
+        const shapeField = codeSchema?.shape?.[name];
+        if (shapeField) {
+            propertyType = zod_1.z.intersection(propertyType, shapeField);
         }
         const newProperty = { [name]: propertyType };
         argsSchema = argsSchema.extend(newProperty);
@@ -58,10 +58,10 @@ function schemaToFields(schema) {
         const field = schema.shape[name];
         let type = field_type_1.FieldType.any;
         let _def = field._def;
-        let isArray = undefined;
+        let isArray;
         let brandedFieldType;
         while (true) {
-            if (_def.typeName === 'ZodArray') {
+            if (_def.typeName === "ZodArray") {
                 isArray = true;
             }
             if (_def._fieldType) {
@@ -82,39 +82,40 @@ function schemaToFields(schema) {
             break;
         }
         switch (_def.typeName) {
-            case 'ZodString':
+            case "ZodString":
                 type = brandedFieldType || field_type_1.FieldType.string;
                 break;
-            case 'ZodNumber':
+            case "ZodNumber":
                 type = field_type_1.FieldType.number;
                 break;
-            case 'ZodBoolean':
+            case "ZodBoolean":
                 type = field_type_1.FieldType.boolean;
                 break;
-            case 'ZodDate':
+            case "ZodDate":
                 type = field_type_1.FieldType.Date;
                 break;
-            case 'ZodObject':
+            case "ZodObject":
                 type = field_type_1.FieldType.object;
                 break;
-            case 'ZodNativeEnum':
+            case "ZodNativeEnum": {
                 // number or string
-                const hasNumber = Object.values(_def.values).some(v => typeof v === 'number');
+                const hasNumber = Object.values(_def.values).some((v) => typeof v === "number");
                 type = hasNumber ? field_type_1.FieldType.number : field_type_1.FieldType.string;
                 break;
+            }
             default:
                 type = field_type_1.FieldType.any;
         }
-        if (!isArray && field._def.typeName === 'ZodArray') {
+        if (!isArray && field._def.typeName === "ZodArray") {
             isArray = true;
             // isArray = field._def.typeName === 'ZodArray' || undefined;
         }
-        const optional = field._def.typeName === 'ZodOptional' || undefined;
+        const optional = field._def.typeName === "ZodOptional" || undefined;
         const description = field._def.description;
         const defaultValue = field._def.defaultValue;
         const newField = { name, type, isArray, optional, description, defaultValue };
-        Object.keys(newField).forEach(k => {
-            // @ts-ignore
+        Object.keys(newField).forEach((k) => {
+            // @ts-expect-error
             if (newField[k] === undefined)
                 delete newField[k];
         });

package/dist/data/orm/types.test.js

@@ -1,38 +1,70 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const zod_1 = require("zod");
-const types_1 = require("./types");
 const field_type_1 = require("../../types/field-type");
-const utils_1 = require("../../utils");
 const zod_types_1 = require("../../types/zod-types");
-describe('types', () => {
-    it('fieldsToSchema', () => {
+const utils_1 = require("../../utils");
+const types_1 = require("./types");
+describe("types", () => {
+    it("fieldsToSchema", () => {
         const someDate = new Date();
         const groupFields = [
-            { name: 'groupId', description: 'The id of the group', type: field_type_1.FieldType.id },
-            { name: 'groupName', description: 'The name of the group', type: field_type_1.FieldType.string },
-            { name: 'groupDescription', description: 'The description of the group', type: field_type_1.FieldType.string },
-            { name: 'createdAt', description: 'The date the group was created', type: field_type_1.FieldType.Date, defaultValue: () => someDate },
-            { name: 'owningUserIds', description: 'The ids of the users who own the group', type: field_type_1.FieldType.string, isArray: true },
-            { name: 'isPublic', description: 'Whether the group is public or private', type: field_type_1.FieldType.boolean, optional: true },
-            { name: 'fileIds', description: 'The ids of files attached to this chat entry', type: field_type_1.FieldType.string, isArray: true, optional: true },
+            { name: "groupId", description: "The id of the group", type: field_type_1.FieldType.id },
+            { name: "groupName", description: "The name of the group", type: field_type_1.FieldType.string },
+            {
+                name: "groupDescription",
+                description: "The description of the group",
+                type: field_type_1.FieldType.string,
+            },
+            {
+                name: "createdAt",
+                description: "The date the group was created",
+                type: field_type_1.FieldType.Date,
+                defaultValue: () => someDate,
+            },
+            {
+                name: "owningUserIds",
+                description: "The ids of the users who own the group",
+                type: field_type_1.FieldType.string,
+                isArray: true,
+            },
+            {
+                name: "isPublic",
+                description: "Whether the group is public or private",
+                type: field_type_1.FieldType.boolean,
+                optional: true,
+            },
+            {
+                name: "fileIds",
+                description: "The ids of files attached to this chat entry",
+                type: field_type_1.FieldType.string,
+                isArray: true,
+                optional: true,
+            },
         ];
         const groupSchema = (0, types_1.fieldsToSchema)(groupFields);
         const groupSchemaExpected = zod_1.z.object({
-            groupId: zod_1.z.string().describe('The id of the group'),
-            groupName: zod_1.z.string().describe('The name of the group'),
-            groupDescription: zod_1.z.string().describe('The description of the group'),
-            createdAt: zod_1.z.date().describe('The date the group was created').default(() => someDate),
-            owningUserIds: zod_1.z.string().array().describe('The ids of the users who own the group'),
-            isPublic: zod_1.z.boolean().optional().describe('Whether the group is public or private'),
-            fileIds: zod_1.z.string().array().optional().describe('The ids of files attached to this chat entry'),
+            groupId: zod_1.z.string().describe("The id of the group"),
+            groupName: zod_1.z.string().describe("The name of the group"),
+            groupDescription: zod_1.z.string().describe("The description of the group"),
+            createdAt: zod_1.z
+                .date()
+                .describe("The date the group was created")
+                .default(() => someDate),
+            owningUserIds: zod_1.z.string().array().describe("The ids of the users who own the group"),
+            isPublic: zod_1.z.boolean().optional().describe("Whether the group is public or private"),
+            fileIds: zod_1.z
+                .string()
+                .array()
+                .optional()
+                .describe("The ids of files attached to this chat entry"),
         });
         const aGroup = {
             groupId: (0, utils_1.newid)(),
-            groupName: 'group',
-            groupDescription: 'group description',
+            groupName: "group",
+            groupDescription: "group description",
             createdAt: new Date(),
-            owningUserIds: ['1'],
+            owningUserIds: ["1"],
             isPublic: true,
         };
         const aGroup2 = { ...aGroup, createdAt: undefined };
@@ -42,104 +74,143 @@ describe('types', () => {
         expect(r1e.createdAt).toEqual(someDate);
         // @ts-expect-error
         delete aGroup.groupId;
-        expect(() => groupSchema.parse(aGroup)).toThrow('groupId');
-        expect(() => groupSchemaExpected.parse(aGroup)).toThrow('groupId');
+        expect(() => groupSchema.parse(aGroup)).toThrow("groupId");
+        expect(() => groupSchemaExpected.parse(aGroup)).toThrow("groupId");
     });
-    it('schemaToFields', () => {
+    it("schemaToFields", () => {
         const groupSchema = zod_1.z.object({
-            groupId: zod_1.z.string().describe('The id of the group'),
-            groupName: zod_1.z.string().describe('The name of the group'),
-            groupDescription: zod_1.z.string().describe('The description of the group'),
-            createdAt: zod_1.z.date().describe('The date the group was created'), //.default(() => new Date()),
-            owningUserIds: zod_1.z.string().array().describe('The ids of the users who own the group'),
-            isPublic: zod_1.z.boolean().optional().describe('Whether the group is public or private'),
-            instructionResults: zod_1.z.any().array().describe('The results of the instructions that have been run.'),
-            fileIds: zod_1.z.string().array().optional().describe('The ids of files attached to this chat entry'),
+            groupId: zod_1.z.string().describe("The id of the group"),
+            groupName: zod_1.z.string().describe("The name of the group"),
+            groupDescription: zod_1.z.string().describe("The description of the group"),
+            createdAt: zod_1.z.date().describe("The date the group was created"), //.default(() => new Date()),
+            owningUserIds: zod_1.z.string().array().describe("The ids of the users who own the group"),
+            isPublic: zod_1.z.boolean().optional().describe("Whether the group is public or private"),
+            instructionResults: zod_1.z
+                .any()
+                .array()
+                .describe("The results of the instructions that have been run."),
+            fileIds: zod_1.z
+                .string()
+                .array()
+                .optional()
+                .describe("The ids of files attached to this chat entry"),
         });
         const groupFields = (0, types_1.schemaToFields)(groupSchema);
         const groupFieldsExpected = [
-            { name: 'groupId', description: 'The id of the group', type: field_type_1.FieldType.string },
-            { name: 'groupName', description: 'The name of the group', type: field_type_1.FieldType.string },
-            { name: 'groupDescription', description: 'The description of the group', type: field_type_1.FieldType.string },
-            { name: 'createdAt', description: 'The date the group was created', type: field_type_1.FieldType.Date, }, //defaultValue: () => new Date() },
-            { name: 'owningUserIds', description: 'The ids of the users who own the group', type: field_type_1.FieldType.string, isArray: true },
-            { name: 'isPublic', description: 'Whether the group is public or private', type: field_type_1.FieldType.boolean, optional: true },
-            { name: 'instructionResults', description: 'The results of the instructions that have been run.', type: field_type_1.FieldType.any, isArray: true },
-            { name: 'fileIds', description: 'The ids of files attached to this chat entry', type: field_type_1.FieldType.string, isArray: true, optional: true },
+            { name: "groupId", description: "The id of the group", type: field_type_1.FieldType.string },
+            { name: "groupName", description: "The name of the group", type: field_type_1.FieldType.string },
+            {
+                name: "groupDescription",
+                description: "The description of the group",
+                type: field_type_1.FieldType.string,
+            },
+            { name: "createdAt", description: "The date the group was created", type: field_type_1.FieldType.Date }, //defaultValue: () => new Date() },
+            {
+                name: "owningUserIds",
+                description: "The ids of the users who own the group",
+                type: field_type_1.FieldType.string,
+                isArray: true,
+            },
+            {
+                name: "isPublic",
+                description: "Whether the group is public or private",
+                type: field_type_1.FieldType.boolean,
+                optional: true,
+            },
+            {
+                name: "instructionResults",
+                description: "The results of the instructions that have been run.",
+                type: field_type_1.FieldType.any,
+                isArray: true,
+            },
+            {
+                name: "fileIds",
+                description: "The ids of files attached to this chat entry",
+                type: field_type_1.FieldType.string,
+                isArray: true,
+                optional: true,
+            },
         ];
         expect(groupFields).toEqual(groupFieldsExpected);
     });
-    it('schemaToFields should detect zodPeerId as FieldType.id', () => {
+    it("schemaToFields should detect zodPeerId as FieldType.id", () => {
         const schema = zod_1.z.object({
-            recordId: zod_types_1.zodPeerId.describe('A peer id field'),
-            optionalRef: zod_types_1.zodPeerId.optional().describe('An optional peer id'),
+            recordId: zod_types_1.zodPeerId.describe("A peer id field"),
+            optionalRef: zod_types_1.zodPeerId.optional().describe("An optional peer id"),
         });
         const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields.find(f => f.name === 'recordId').type).toBe(field_type_1.FieldType.id);
-        expect(fields.find(f => f.name === 'optionalRef').type).toBe(field_type_1.FieldType.id);
+        expect(fields.find((f) => f.name === "recordId")?.type).toBe(field_type_1.FieldType.id);
+        expect(fields.find((f) => f.name === "optionalRef")?.type).toBe(field_type_1.FieldType.id);
     });
-    it('schemaToFields should NOT classify plain z.string() as id just because name ends in Id', () => {
+    it("schemaToFields should NOT classify plain z.string() as id just because name ends in Id", () => {
         const schema = zod_1.z.object({
-            externalId: zod_1.z.string().describe('An external system identifier'),
-            channelId: zod_1.z.string().describe('A channel reference'),
-            name: zod_1.z.string().describe('A plain string'),
+            externalId: zod_1.z.string().describe("An external system identifier"),
+            channelId: zod_1.z.string().describe("A channel reference"),
+            name: zod_1.z.string().describe("A plain string"),
         });
         const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields.find(f => f.name === 'externalId').type).toBe(field_type_1.FieldType.string);
-        expect(fields.find(f => f.name === 'channelId').type).toBe(field_type_1.FieldType.string);
-        expect(fields.find(f => f.name === 'name').type).toBe(field_type_1.FieldType.string);
+        expect(fields.find((f) => f.name === "externalId")?.type).toBe(field_type_1.FieldType.string);
+        expect(fields.find((f) => f.name === "channelId")?.type).toBe(field_type_1.FieldType.string);
+        expect(fields.find((f) => f.name === "name")?.type).toBe(field_type_1.FieldType.string);
     });
-    it('schemaToFields should NOT classify a non-id string refinement as FieldType.id', () => {
-        const zodEmail = zod_1.z.string().refine(val => val.includes('@'), { message: 'Must be an email' });
-        const zodNonEmpty = zod_1.z.string().refine(val => val.length > 0, { message: 'Must not be empty' });
+    it("schemaToFields should NOT classify a non-id string refinement as FieldType.id", () => {
+        const zodEmail = zod_1.z.string().refine((val) => val.includes("@"), { message: "Must be an email" });
+        const zodNonEmpty = zod_1.z
+            .string()
+            .refine((val) => val.length > 0, { message: "Must not be empty" });
         const schema = zod_1.z.object({
-            email: zodEmail.describe('An email address'),
-            requiredField: zodNonEmpty.describe('A non-empty string'),
-            peerId: zod_types_1.zodPeerId.describe('A real peer id'),
+            email: zodEmail.describe("An email address"),
+            requiredField: zodNonEmpty.describe("A non-empty string"),
+            peerId: zod_types_1.zodPeerId.describe("A real peer id"),
         });
         const fields = (0, types_1.schemaToFields)(schema);
-        expect(fields.find(f => f.name === 'email').type).toBe(field_type_1.FieldType.string);
-        expect(fields.find(f => f.name === 'requiredField').type).toBe(field_type_1.FieldType.string);
-        expect(fields.find(f => f.name === 'peerId').type).toBe(field_type_1.FieldType.id);
+        expect(fields.find((f) => f.name === "email")?.type).toBe(field_type_1.FieldType.string);
+        expect(fields.find((f) => f.name === "requiredField")?.type).toBe(field_type_1.FieldType.string);
+        expect(fields.find((f) => f.name === "peerId")?.type).toBe(field_type_1.FieldType.id);
     });
-    it('fieldsToSchema should merge with optional code schema for most-constrained validation', () => {
+    it("fieldsToSchema should merge with optional code schema for most-constrained validation", () => {
         const codeSchema = zod_1.z.object({
-            recordId: zod_types_1.zodPeerId.describe('A peer id'),
-            label: zod_1.z.string().min(1).describe('Non-empty label'),
+            recordId: zod_types_1.zodPeerId.describe("A peer id"),
+            label: zod_1.z.string().min(1).describe("Non-empty label"),
         });
         const fields = [
-            { name: 'recordId', description: 'A peer id', type: field_type_1.FieldType.string },
-            { name: 'label', description: 'Non-empty label', type: field_type_1.FieldType.string },
+            { name: "recordId", description: "A peer id", type: field_type_1.FieldType.string },
+            { name: "label", description: "Non-empty label", type: field_type_1.FieldType.string },
         ];
         const mergedSchema = (0, types_1.fieldsToSchema)(fields, codeSchema);
         const validId = (0, utils_1.newid)();
         // Valid peer id should pass the merged schema
-        expect(() => mergedSchema.parse({ recordId: validId, label: 'hello' })).not.toThrow();
+        expect(() => mergedSchema.parse({ recordId: validId, label: "hello" })).not.toThrow();
         // Empty string should fail: the code schema's zodPeerId rejects it
-        expect(() => mergedSchema.parse({ recordId: '', label: 'hello' })).toThrow();
+        expect(() => mergedSchema.parse({ recordId: "", label: "hello" })).toThrow();
         // Empty label should fail: the code schema's .min(1) rejects it
-        expect(() => mergedSchema.parse({ recordId: validId, label: '' })).toThrow();
+        expect(() => mergedSchema.parse({ recordId: validId, label: "" })).toThrow();
     });
-    it('round-trip: fieldsToSchema id fields should survive schemaToFields detection', () => {
+    it("round-trip: fieldsToSchema id fields should survive schemaToFields detection", () => {
         // fieldsToSchema creates z.string().refine(isid) for FieldType.id fields.
         // schemaToFields should detect that refinement as FieldType.id so round-trips are consistent.
         const fields = [
-            { name: 'recordId', description: 'A peer id', type: field_type_1.FieldType.id },
-            { name: 'label', description: 'A label', type: field_type_1.FieldType.string },
+            { name: "recordId", description: "A peer id", type: field_type_1.FieldType.id },
+            { name: "label", description: "A label", type: field_type_1.FieldType.string },
         ];
         const schema = (0, types_1.fieldsToSchema)(fields);
         const roundTrippedFields = (0, types_1.schemaToFields)(schema);
-        expect(roundTrippedFields.find(f => f.name === 'recordId').type).toBe(field_type_1.FieldType.id);
-        expect(roundTrippedFields.find(f => f.name === 'label').type).toBe(field_type_1.FieldType.string);
+        expect(roundTrippedFields.find((f) => f.name === "recordId")?.type).toBe(field_type_1.FieldType.id);
+        expect(roundTrippedFields.find((f) => f.name === "label")?.type).toBe(field_type_1.FieldType.string);
     });
-    it('fieldsToSchema merge should handle optional zodPeerId fields correctly', () => {
+    it("fieldsToSchema merge should handle optional zodPeerId fields correctly", () => {
         const codeSchema = zod_1.z.object({
-            ownerId: zod_types_1.zodPeerId.describe('The owner'),
-            referrerId: zod_types_1.zodPeerId.optional().describe('Optional referrer'),
+            ownerId: zod_types_1.zodPeerId.describe("The owner"),
+            referrerId: zod_types_1.zodPeerId.optional().describe("Optional referrer"),
         });
         const fields = [
-            { name: 'ownerId', description: 'The owner', type: field_type_1.FieldType.string },
-            { name: 'referrerId', description: 'Optional referrer', type: field_type_1.FieldType.string, optional: true },
+            { name: "ownerId", description: "The owner", type: field_type_1.FieldType.string },
+            {
+                name: "referrerId",
+                description: "Optional referrer",
+                type: field_type_1.FieldType.string,
+                optional: true,
+            },
         ];
         const mergedSchema = (0, types_1.fieldsToSchema)(fields, codeSchema);
         const validId = (0, utils_1.newid)();
@@ -149,18 +220,21 @@ describe('types', () => {
         // Optional field omitted
         expect(() => mergedSchema.parse({ ownerId: validId })).not.toThrow();
         // Optional field present but invalid
-        expect(() => mergedSchema.parse({ ownerId: validId, referrerId: 'not-a-valid-id' })).toThrow();
+        expect(() => mergedSchema.parse({ ownerId: validId, referrerId: "not-a-valid-id" })).toThrow();
         // Required field missing
         expect(() => mergedSchema.parse({ referrerId: validId })).toThrow();
         // Required field invalid
-        expect(() => mergedSchema.parse({ ownerId: 'bad', referrerId: validId })).toThrow();
+        expect(() => mergedSchema.parse({ ownerId: "bad", referrerId: validId })).toThrow();
     });
-    it('initRecord pattern: code schema defaults should work even after JSON round-trip of fields', () => {
+    it("initRecord pattern: code schema defaults should work even after JSON round-trip of fields", () => {
         const codeSchema = zod_1.z.object({
-            recordId: zod_types_1.zodPeerId.describe('A peer id'),
-            label: zod_1.z.string().default('untitled').describe('A label with default'),
-            createdAt: zod_1.z.date().default(() => new Date()).describe('Date with factory default'),
-            count: zod_1.z.number().default(0).describe('A count with default'),
+            recordId: zod_types_1.zodPeerId.describe("A peer id"),
+            label: zod_1.z.string().default("untitled").describe("A label with default"),
+            createdAt: zod_1.z
+                .date()
+                .default(() => new Date())
+                .describe("Date with factory default"),
+            count: zod_1.z.number().default(0).describe("A count with default"),
         });
         // Simulate the real flow: code schema -> fields -> JSON (sync) -> parse back
         const fields = (0, types_1.schemaToFields)(codeSchema);
@@ -188,19 +262,19 @@ describe('types', () => {
             }
         }
         const result = { ...defaults, ...data };
-        expect(result.label).toBe('untitled');
+        expect(result.label).toBe("untitled");
         expect(result.createdAt).toBeInstanceOf(Date);
         expect(result.count).toBe(0);
         expect(result.recordId).toBe(validId);
     });
-    it('fieldsToSchema without code schema should work as before', () => {
+    it("fieldsToSchema without code schema should work as before", () => {
         const fields = [
-            { name: 'recordId', description: 'A peer id', type: field_type_1.FieldType.id },
-            { name: 'label', description: 'A label', type: field_type_1.FieldType.string },
+            { name: "recordId", description: "A peer id", type: field_type_1.FieldType.id },
+            { name: "label", description: "A label", type: field_type_1.FieldType.string },
         ];
         const schema = (0, types_1.fieldsToSchema)(fields);
         const validId = (0, utils_1.newid)();
-        expect(() => schema.parse({ recordId: validId, label: 'hello' })).not.toThrow();
-        expect(() => schema.parse({ recordId: '', label: 'hello' })).toThrow();
+        expect(() => schema.parse({ recordId: validId, label: "hello" })).not.toThrow();
+        expect(() => schema.parse({ recordId: "", label: "hello" })).toThrow();
     });
 });

package/dist/data/package-permissions.d.ts

@@ -1,4 +1,4 @@
-import type { IPackage } from './packages';
+import type { IPackage } from "./packages";
 /**
  * Verifies that a package update signature is valid, throws on invalid signature
  * @param packageObj The package record to verify

package/dist/data/package-permissions.js

@@ -10,9 +10,9 @@ const group_permissions_1 = require("./group-permissions");
  */
 async function verifyPackageSignature(packageObj, groupId) {
     (0, keys_1.verifyObjectSignature)(packageObj);
-    const signerPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(packageObj) ?? '';
+    const signerPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(packageObj) ?? "";
     const signerRole = await (0, group_permissions_1.getUserRoleFromPublicKey)(groupId, signerPublicKey);
     if (signerRole < group_permissions_1.GroupMemberRole.Admin) {
-        throw new Error('Only group admins can create or update packages');
+        throw new Error("Only group admins can create or update packages");
     }
 }

package/dist/data/package-version-permissions.d.ts

@@ -1,4 +1,4 @@
-import type { IPackageVersion } from './package-versions';
+import type { IPackageVersion } from "./package-versions";
 /**
  * Verifies that a package version update signature is valid, throws on invalid signature
  * @param packageVersion The package version record to verify

package/dist/data/package-version-permissions.js

@@ -10,9 +10,9 @@ const group_permissions_1 = require("./group-permissions");
  */
 async function verifyPackageVersionSignature(packageVersion, groupId) {
     (0, keys_1.verifyObjectSignature)(packageVersion);
-    const signerPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(packageVersion) ?? '';
+    const signerPublicKey = (0, keys_1.getPublicKeyFromObjectSignature)(packageVersion) ?? "";
     const signerRole = await (0, group_permissions_1.getUserRoleFromPublicKey)(groupId, signerPublicKey);
     if (signerRole < group_permissions_1.GroupMemberRole.Admin) {
-        throw new Error('Only group admins can create or update package versions');
+        throw new Error("Only group admins can create or update package versions");
     }
 }

package/dist/data/package-versions.d.ts

@@ -34,15 +34,15 @@ declare const schema: z.ZodObject<{
     createdBy: z.ZodEffects<z.ZodString, string, string>;
     createdAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    version: string;
     signature: string;
-    createdBy: string;
-    createdAt: string;
-    packageId: string;
     packageVersionId: string;
-    version: string;
+    packageId: string;
     packageVersionHash: string;
     packageBundleFileId: string;
     packageBundleFileHash: string;
+    createdBy: string;
+    createdAt: string;
     versionTag?: string | undefined;
     routesBundleFileId?: string | undefined;
     routesBundleFileHash?: string | undefined;
@@ -55,15 +55,15 @@ declare const schema: z.ZodObject<{
         displayName?: string | undefined;
     }[] | undefined;
 }, {
+    version: string;
     signature: string;
-    createdBy: string;
-    createdAt: string;
-    packageId: string;
     packageVersionId: string;
-    version: string;
+    packageId: string;
     packageVersionHash: string;
     packageBundleFileId: string;
     packageBundleFileHash: string;
+    createdBy: string;
+    createdAt: string;
     versionTag?: string | undefined;
     routesBundleFileId?: string | undefined;
     routesBundleFileHash?: string | undefined;
@@ -91,7 +91,7 @@ export declare function PackageVersions(dataContext?: DataContext): PackageVersi
  * Compute a hash combining the bundle file hashes to uniquely identify this version's content.
  */
 export declare function computePackageVersionHash(version: string, versionTag: string, packageBundleFileHash: string, routesBundleFileHash?: string, uiBundleFileHash?: string): string;
-export declare function isVersionInRange(activeVersion: string, incomingVersion: string, range: 'pinned' | 'patch' | 'minor' | 'latest'): boolean;
+export declare function isVersionInRange(activeVersion: string, incomingVersion: string, range: "pinned" | "patch" | "minor" | "latest"): boolean;
 /**
  * Returns true if incomingVersion is strictly newer than activeVersion (semver comparison).
  */