@peers-app/peers-sdk 0.1.4

package/dist/data/orm/table.js

@@ -0,0 +1,244 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Table = void 0;
+exports.getIconClassName = getIconClassName;
+const data_query_1 = require("./data-query");
+const doc_1 = require("./doc");
+const subscribable_data_source_1 = require("./subscribable.data-source");
+const types_1 = require("./types");
+const utils_1 = require("../../utils");
+const rpc_types_1 = require("../../rpc-types");
+const lodash_1 = require("lodash");
+class Table {
+    tableName;
+    primaryKeyName;
+    schema;
+    dataChangedEmitter;
+    dataChanged;
+    localOperationCache = new Map();
+    dataSource;
+    metaData;
+    groupId;
+    constructor(metaData, deps) {
+        this.metaData = metaData;
+        this.dataSource = deps.dataSource;
+        this.schema = deps.schema || (0, types_1.fieldsToSchema)(metaData.fields);
+        this.groupId = deps.groupId;
+        this.tableName = (0, utils_1.getFullTableName)(metaData);
+        this.primaryKeyName = metaData.primaryKeyName;
+        // Event setup with explicit dependency
+        const eventName = this.tableName + "_DataChanged";
+        this.dataChangedEmitter = deps.eventRegistry.getEmitter(eventName);
+        this.dataChanged = this.dataChangedEmitter.event;
+        if (rpc_types_1.isClient) {
+            // hack to not emit duplicate events from local client tables
+            this.dataChangedEmitter.emit = lodash_1.noop;
+        }
+        // Validation (works for both patterns since this.metaData is set)
+        const primaryKeyIsValid = this.metaData.fields.find(f => f.name === this.metaData.primaryKeyName);
+        if (!primaryKeyIsValid) {
+            throw new Error(`Table "${this.tableName}", primary key "${this.metaData.primaryKeyName}" is not a valid field name`);
+        }
+        // Find any underlying SubscribableDataSource to intercept its events
+        let subscribableDataSource = undefined;
+        let _dataSource = this.dataSource;
+        while (!subscribableDataSource && _dataSource) {
+            if (_dataSource instanceof subscribable_data_source_1.SubscribableDataSource) {
+                subscribableDataSource = _dataSource;
+                break;
+            }
+            else {
+                // traverse to the underlying data source to try to find a SubscribableDataSource
+                _dataSource = _dataSource.dataSource;
+            }
+        }
+        // Event setup is now handled in constructor above
+        // Intercept and forward events with appropriate source marking
+        if (subscribableDataSource) {
+            subscribableDataSource.dataChanged.subscribe((event) => {
+                const recordId = this.getRecordId(event.dataObject);
+                const cacheKey = `${recordId}-${event.op}`;
+                if (!this.localOperationCache.has(cacheKey)) {
+                    this.dataChangedEmitter.emit({
+                        dataObject: event.dataObject,
+                        op: event.op,
+                        source: 'remote',
+                    });
+                }
+            });
+        }
+    }
+    getRecordId(record) {
+        return record[this.primaryKeyName];
+    }
+    setLocalOperation(recordId, operation) {
+        const cacheKey = `${recordId}-${operation}`;
+        this.localOperationCache.set(cacheKey, true);
+    }
+    clearLocalOperation(recordId, operation) {
+        const cacheKey = `${recordId}-${operation}`;
+        this.localOperationCache.delete(cacheKey);
+    }
+    cachedRecords = {};
+    async get(id, opts = {}) {
+        const { useCache } = opts;
+        let cacheTtlMs = opts.cacheTtlMs || 1000 * 30; // cache ttl default is 30 seconds
+        if (useCache && this.cachedRecords[id]) {
+            return this.cachedRecords[id];
+        }
+        const promise = new Promise(async (resolve, reject) => {
+            try {
+                let record;
+                record = await this.dataSource.get(id);
+                if (!record) {
+                    cacheTtlMs = 1000; // very short cache ttl for non-existent records
+                }
+                resolve(record);
+            }
+            catch (err) {
+                cacheTtlMs = 1000; // very short cache ttl on error
+                reject(err);
+            }
+            finally {
+                setTimeout(() => {
+                    delete this.cachedRecords[id];
+                }, cacheTtlMs);
+            }
+        });
+        if (useCache) {
+            this.cachedRecords[id] = promise;
+        }
+        return promise;
+    }
+    async list(filter = {}, opts = {}) {
+        return this.dataSource.list(filter, opts);
+    }
+    ;
+    async count(filter = {}) {
+        return (0, data_query_1.dataSourceCount)(this.dataSource, filter);
+    }
+    ;
+    cursor(filter = {}, opts = {}) {
+        return (0, data_query_1.dataSourceCursor)(this.dataSource, filter, opts);
+    }
+    async findOne(filter = {}, opts = {}) {
+        if (!opts?.enforceUnique) {
+            const records = await this.list(filter, { pageSize: 1 });
+            return records[0];
+        }
+        else {
+            const records = await this.list(filter, { pageSize: 2 });
+            if (records.length > 1) {
+                throw new Error(`Matched more than one record for ${this.tableName} with query ${JSON.stringify(filter)}`);
+            }
+            return records[0];
+        }
+    }
+    async save(record, opts) {
+        const recordId = this.getRecordId(record);
+        if (recordId) {
+            delete this.cachedRecords[recordId];
+        }
+        const isInsert = !recordId || !(await this.get(recordId));
+        const operation = isInsert ? 'insert' : 'update';
+        this.setLocalOperation(recordId, operation);
+        let result;
+        try {
+            // if (isInsert) {
+            //   result = await this.dataSource.insert(record);
+            // } else {
+            //   result = await this.dataSource.update(record);
+            // }
+            result = await this.dataSource.save(record, opts);
+        }
+        finally {
+            this.clearLocalOperation(recordId, operation);
+        }
+        this.dataChangedEmitter.emit({
+            dataObject: result,
+            op: operation,
+            source: 'local',
+        });
+        return result;
+    }
+    async insert(record) {
+        const recordId = this.getRecordId(record);
+        this.setLocalOperation(recordId, 'insert');
+        let result;
+        try {
+            result = await this.dataSource.insert(record);
+        }
+        finally {
+            this.clearLocalOperation(recordId, 'insert');
+        }
+        this.dataChangedEmitter.emit({
+            dataObject: result,
+            op: 'insert',
+            source: 'local',
+        });
+        return result;
+    }
+    async update(record) {
+        delete this.cachedRecords[record[this.metaData.primaryKeyName]];
+        const recordId = this.getRecordId(record);
+        this.setLocalOperation(recordId, 'update');
+        let result;
+        try {
+            result = await this.dataSource.update(record);
+        }
+        finally {
+            this.clearLocalOperation(recordId, 'update');
+        }
+        this.dataChangedEmitter.emit({
+            dataObject: result,
+            op: 'update',
+            source: 'local',
+        });
+        return result;
+    }
+    async delete(idOrRecord) {
+        const primaryKey = typeof idOrRecord === 'string' ? idOrRecord : idOrRecord[this.metaData.primaryKeyName];
+        const existingRecord = typeof idOrRecord === 'object' ? idOrRecord : await this.get(primaryKey);
+        delete this.cachedRecords[primaryKey];
+        if (!existingRecord) {
+            return; // nothing to delete
+        }
+        this.setLocalOperation(primaryKey, 'delete');
+        try {
+            await this.dataSource.delete(idOrRecord);
+        }
+        finally {
+            this.clearLocalOperation(primaryKey, 'delete');
+        }
+        this.dataChangedEmitter.emit({
+            dataObject: existingRecord,
+            op: 'delete',
+            source: 'local',
+        });
+    }
+    initRecord(data = {}) {
+        const defaults = {};
+        for (const field of this.metaData.fields) {
+            const zodField = this.schema.shape[field.name];
+            const value = zodField.safeParse(data[field.name]);
+            if (value.success) {
+                // @ts-ignore
+                defaults[field.name] = value.data;
+            }
+        }
+        return { ...defaults, ...data };
+    }
+    initDoc(record) {
+        return (0, doc_1.initDoc)(record, this);
+    }
+    getDoc(id) {
+        // TODO figure out the best way to make this work with react+observables
+        const doc = (0, doc_1.initDoc)({ [this.metaData.primaryKeyName]: id }, this);
+        // doc.load();
+        return doc;
+    }
+}
+exports.Table = Table;
+function getIconClassName(table) {
+    return table.metaData.iconClassName ?? 'bi bi-question';
+}

package/dist/data/orm/types.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+import { IField } from '../../types/field-type';
+export interface ITableMetaData {
+    tableId?: string;
+    name: string;
+    description: string;
+    primaryKeyName: string;
+    fields: IField[];
+    indexes?: {
+        fields: (string | {
+            name: string;
+            order: 'ASC' | 'DESC';
+        })[];
+        unique?: true;
+    }[];
+    iconClassName?: string;
+    localOnly?: boolean;
+}
+export declare function fieldsToSchema(fields: IField[]): z.AnyZodObject;
+export declare function schemaToFields(schema: z.AnyZodObject): IField[];

package/dist/data/orm/types.js

@@ -0,0 +1,115 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fieldsToSchema = fieldsToSchema;
+exports.schemaToFields = schemaToFields;
+const zod_1 = require("zod");
+const field_type_1 = require("../../types/field-type");
+const utils_1 = require("../../utils");
+function fieldsToSchema(fields) {
+    let argsSchema = zod_1.z.object({});
+    for (const argSchema of fields) {
+        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' });
+                break;
+            case 'string':
+                propertyType = zod_1.z.string();
+                break;
+            case 'number':
+                propertyType = zod_1.z.number();
+                break;
+            case 'boolean':
+                propertyType = zod_1.z.boolean();
+                break;
+            case 'Date':
+                propertyType = zod_1.z.date();
+                break;
+            case 'object':
+                propertyType = zod_1.z.object({});
+                break;
+            default:
+                propertyType = zod_1.z.any();
+        }
+        if (isArray) {
+            propertyType = propertyType.array();
+        }
+        if (optional) {
+            propertyType = propertyType.optional();
+        }
+        if (defaultValue) {
+            // @ts-ignore
+            propertyType = propertyType.default(defaultValue);
+        }
+        propertyType = propertyType.describe(description);
+        const newProperty = { [name]: propertyType };
+        argsSchema = argsSchema.extend(newProperty);
+    }
+    return argsSchema;
+}
+function schemaToFields(schema) {
+    const fields = [];
+    for (const name of Object.keys(schema.shape)) {
+        const field = schema.shape[name];
+        let type = field_type_1.FieldType.any;
+        let _def = field._def;
+        let isArray = undefined;
+        while (true) {
+            if (_def.typeName === 'ZodArray') {
+                isArray = true;
+            }
+            if (_def.innerType) {
+                _def = _def.innerType._def;
+                continue;
+            }
+            if (_def.type) {
+                _def = _def.type._def;
+                continue;
+            }
+            break;
+        }
+        switch (_def.typeName) {
+            case 'ZodString':
+                type = field_type_1.FieldType.string;
+                break;
+            case 'ZodNumber':
+                type = field_type_1.FieldType.number;
+                break;
+            case 'ZodBoolean':
+                type = field_type_1.FieldType.boolean;
+                break;
+            case 'ZodDate':
+                type = field_type_1.FieldType.Date;
+                break;
+            case 'ZodObject':
+                type = field_type_1.FieldType.object;
+                break;
+            case 'ZodNativeEnum':
+                // number or string
+                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 ((name === 'id' || name.endsWith('Id')) && type === 'string') {
+            type = field_type_1.FieldType.id;
+        }
+        if (!isArray && field._def.typeName === 'ZodArray') {
+            isArray = true;
+            // isArray = field._def.typeName === 'ZodArray' || 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
+            if (newField[k] === undefined)
+                delete newField[k];
+        });
+        fields.push(newField);
+    }
+    return fields;
+}

package/dist/data/orm/types.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,71 @@
+"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");
+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 },
+        ];
+        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'),
+        });
+        const aGroup = {
+            groupId: (0, utils_1.newid)(),
+            groupName: 'group',
+            groupDescription: 'group description',
+            createdAt: new Date(),
+            owningUserIds: ['1'],
+            isPublic: true,
+        };
+        const aGroup2 = { ...aGroup, createdAt: undefined };
+        const r1 = groupSchema.parse(aGroup2);
+        const r1e = groupSchemaExpected.parse(aGroup2);
+        expect(r1.createdAt).toEqual(someDate);
+        expect(r1e.createdAt).toEqual(someDate);
+        // @ts-expect-error
+        delete aGroup.groupId;
+        expect(() => groupSchema.parse(aGroup)).toThrow('groupId');
+        expect(() => groupSchemaExpected.parse(aGroup)).toThrow('groupId');
+    });
+    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'),
+        });
+        const groupFields = (0, types_1.schemaToFields)(groupSchema);
+        const groupFieldsExpected = [
+            { 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: () => 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);
+    });
+});

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

@@ -0,0 +1,7 @@
+import type { IPackage } from './packages';
+/**
+ * Verifies that a package update signature is valid, throws on invalid signature
+ * @param packageObj The package record to verify
+ * @throws Error if signature is invalid or unauthorized
+ */
+export declare function verifyPackageSignature(packageObj: IPackage, groupId: string): Promise<void>;

package/dist/data/package-permissions.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.verifyPackageSignature = verifyPackageSignature;
+const keys_1 = require("../keys");
+const group_permissions_1 = require("./group-permissions");
+/**
+ * Verifies that a package update signature is valid, throws on invalid signature
+ * @param packageObj The package record to verify
+ * @throws Error if signature is invalid or unauthorized
+ */
+async function verifyPackageSignature(packageObj, groupId) {
+    (0, keys_1.verifyObjectSignature)(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');
+    }
+}

package/dist/data/packages.d.ts

@@ -0,0 +1,92 @@
+import { z } from "zod";
+import type { DataContext } from "../context/data-context";
+import { ISaveOptions, Table } from "./orm";
+declare const schema: z.ZodObject<{
+    packageId: z.ZodString;
+    name: z.ZodString;
+    description: z.ZodString;
+    createdBy: z.ZodString;
+    localPath: z.ZodString;
+    disabled: z.ZodOptional<z.ZodBoolean>;
+    remoteRepo: z.ZodOptional<z.ZodString>;
+    appNavs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        displayName: z.ZodOptional<z.ZodString>;
+        iconClassName: z.ZodString;
+        navigationPath: z.ZodString;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        iconClassName: string;
+        navigationPath: string;
+        displayName?: string | undefined;
+    }, {
+        name: string;
+        iconClassName: string;
+        navigationPath: string;
+        displayName?: string | undefined;
+    }>, "many">>;
+    packageBundleFileId: z.ZodString;
+    packageBundleFileHash: z.ZodString;
+    routesBundleFileId: z.ZodOptional<z.ZodString>;
+    routesBundleFileHash: z.ZodOptional<z.ZodString>;
+    uiBundleFileId: z.ZodOptional<z.ZodString>;
+    uiBundleFileHash: z.ZodOptional<z.ZodString>;
+    signature: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    signature: string;
+    createdBy: string;
+    packageId: string;
+    localPath: string;
+    packageBundleFileId: string;
+    packageBundleFileHash: string;
+    disabled?: boolean | undefined;
+    remoteRepo?: string | undefined;
+    appNavs?: {
+        name: string;
+        iconClassName: string;
+        navigationPath: string;
+        displayName?: string | undefined;
+    }[] | undefined;
+    routesBundleFileId?: string | undefined;
+    routesBundleFileHash?: string | undefined;
+    uiBundleFileId?: string | undefined;
+    uiBundleFileHash?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    signature: string;
+    createdBy: string;
+    packageId: string;
+    localPath: string;
+    packageBundleFileId: string;
+    packageBundleFileHash: string;
+    disabled?: boolean | undefined;
+    remoteRepo?: string | undefined;
+    appNavs?: {
+        name: string;
+        iconClassName: string;
+        navigationPath: string;
+        displayName?: string | undefined;
+    }[] | undefined;
+    routesBundleFileId?: string | undefined;
+    routesBundleFileHash?: string | undefined;
+    uiBundleFileId?: string | undefined;
+    uiBundleFileHash?: string | undefined;
+}>;
+export type IPackage = z.infer<typeof schema>;
+export declare class PackagesTable extends Table<IPackage> {
+    static isPassthrough: boolean;
+    insert(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
+    update(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
+    save(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
+    signAndSave(packageObj: IPackage, opts?: ISaveOptions): Promise<IPackage>;
+    private static addSignatureToPackage;
+    static enablePackageSigning(fn: (packageObj: IPackage) => IPackage): void;
+    delete(packageId: string): Promise<void>;
+}
+export declare function Packages(dataContext?: DataContext): PackagesTable;
+export declare const packagesRootDir: import("./persistent-vars").PersistentVar<string>;
+export declare const reloadPackagesOnPageRefresh: import("./persistent-vars").PersistentVar<boolean>;
+export {};

package/dist/data/packages.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.reloadPackagesOnPageRefresh = exports.packagesRootDir = exports.PackagesTable = void 0;
+exports.Packages = Packages;
+const zod_1 = require("zod");
+const app_nav_1 = require("../types/app-nav");
+const types_1 = require("./orm/types");
+const persistent_vars_1 = require("./persistent-vars");
+const table_definitions_system_1 = require("./orm/table-definitions.system");
+const context_1 = require("../context");
+const orm_1 = require("./orm");
+const package_permissions_1 = require("./package-permissions");
+const schema = zod_1.z.object({
+    packageId: zod_1.z.string(),
+    name: zod_1.z.string(),
+    description: zod_1.z.string(),
+    createdBy: zod_1.z.string().describe('The user who created the package'),
+    localPath: zod_1.z.string().describe('The local path where the package is stored'),
+    disabled: zod_1.z.boolean().optional().describe("Whether the package's components should be loaded and included in the app runtime"),
+    remoteRepo: zod_1.z.string().optional().describe('The remote repository where the package is stored'),
+    appNavs: app_nav_1.appNavSchema.array().optional().describe('The app navigation items that this package provides'),
+    packageBundleFileId: zod_1.z.string().describe('File ID of the package bundle (required)'),
+    packageBundleFileHash: zod_1.z.string().describe('Hash of the package bundle file (required)'),
+    routesBundleFileId: zod_1.z.string().optional().describe('File ID of the routes bundle (optional)'),
+    routesBundleFileHash: zod_1.z.string().optional().describe('Hash of the routes bundle (optional)'),
+    uiBundleFileId: zod_1.z.string().optional().describe('File ID of the UI bundle (optional)'),
+    uiBundleFileHash: zod_1.z.string().optional().describe('Hash of the UI bundle (optional)'),
+    signature: zod_1.z.string().describe('The signed hash of this data excluding the signature itself'),
+});
+const metaData = {
+    name: 'Packages',
+    description: 'The Peers packages that this computer is aware of (some may be disabled)',
+    primaryKeyName: 'packageId',
+    iconClassName: 'bi bi-box-fill',
+    fields: (0, types_1.schemaToFields)(schema),
+};
+class PackagesTable extends orm_1.Table {
+    static isPassthrough = false;
+    async insert(packageObj, opts) {
+        return this.save(packageObj, opts);
+    }
+    async update(packageObj, opts) {
+        return this.save(packageObj, opts);
+    }
+    async save(packageObj, opts) {
+        if (PackagesTable.isPassthrough) {
+            return super.save(packageObj, opts);
+        }
+        if (!this.groupId) {
+            // users can do whatever they want to packages in their personal space
+            return super.save(packageObj, opts);
+        }
+        try {
+            await (0, package_permissions_1.verifyPackageSignature)(packageObj, this.groupId);
+        }
+        catch (err) {
+            throw new Error('Package verification failed.  Did you mean to call `signAndSave`?', { cause: err });
+        }
+        return super.save(packageObj, opts);
+    }
+    async signAndSave(packageObj, opts) {
+        if (!PackagesTable.addSignatureToPackage) {
+            throw new Error('Package signing is not enabled. Call PackagesTable.enablePackageSigning(fn) to enable it.');
+        }
+        packageObj = await PackagesTable.addSignatureToPackage(packageObj);
+        return super.save(packageObj, opts);
+    }
+    static addSignatureToPackage = undefined;
+    static enablePackageSigning(fn) {
+        this.addSignatureToPackage = fn;
+    }
+    async delete(packageId) {
+        // anyone (with write permissions) can delete packages since that isn't a security risk (unless something else is relying on a package to be present?)
+        return super.delete(packageId);
+        // const userContext = await getUserContext();
+        // const userContextPackages = Packages(userContext.userDataContext);
+        // if (userContextPackages === this) {
+        //   return super.delete(packageId);
+        // }
+        // throw new Error('Only deleting packages from the user context Packages table is allowed');
+    }
+}
+exports.PackagesTable = PackagesTable;
+(0, table_definitions_system_1.registerSystemTableDefinition)(metaData, schema, PackagesTable);
+function Packages(dataContext) {
+    return (0, context_1.getTableContainer)(dataContext).getTable(metaData, schema, PackagesTable);
+}
+exports.packagesRootDir = (0, persistent_vars_1.deviceVar)('packagesRootDir', { defaultValue: '~/peers-packages' });
+exports.reloadPackagesOnPageRefresh = (0, persistent_vars_1.deviceVar)('reloadPackagesOnPageRefresh', { defaultValue: true, });
+// export const packageLocalPathsResolved = persistentVar<{ [packageId: string]: string}>('packageLocalPathsResolved', { defaultValue: {}, scope: 'device' });