@verdant-web/common 1.11.0 → 1.11.1

package/dist/esm/migration.js

@@ -1,122 +1,122 @@
-import { stableStringify, addFieldDefaults, } from './index.js';
-const emptySchema = {
-    version: 0,
-    collections: {},
-};
-export function migrate(oldSchemaOrNewSchema, newSchemaOrProcedure, procedureIfTwoSchemas) {
-    const isProcedureSecondArgument = typeof newSchemaOrProcedure === 'function';
-    const oldSchema = isProcedureSecondArgument
-        ? emptySchema
-        : oldSchemaOrNewSchema;
-    const newSchema = isProcedureSecondArgument
-        ? oldSchemaOrNewSchema
-        : newSchemaOrProcedure;
-    const procedure = isProcedureSecondArgument
-        ? newSchemaOrProcedure
-        : procedureIfTwoSchemas;
-    // diff to determine changed collections
-    const changedCollections = Object.keys(newSchema.collections).filter((key) => oldSchema.collections[key] &&
-        stableStringify(oldSchema.collections[key]) !==
-            stableStringify(newSchema.collections[key]));
-    const removedCollections = Object.keys(oldSchema.collections).filter((key) => !newSchema.collections[key]);
-    const addedCollections = Object.keys(newSchema.collections).filter((key) => !oldSchema.collections[key]);
-    const addedIndexes = {};
-    const removedIndexes = {};
-    for (const changed of [...changedCollections, ...addedCollections]) {
-        const oldIndexes = getIndexes(oldSchema.collections[changed]);
-        const newIndexes = getIndexes(newSchema.collections[changed]);
-        const added = newIndexes.filter((index) => !oldIndexes.find((i) => i.name === index.name));
-        const removed = oldIndexes.filter((index) => !newIndexes.find((i) => i.name === index.name));
-        if (added.length > 0) {
-            addedIndexes[changed] = added;
-        }
-        if (removed.length > 0) {
-            removedIndexes[changed] = removed;
-        }
-    }
-    return {
-        version: newSchema.version,
-        migrate: async (engine) => {
-            const migratedCollections = [];
-            await procedure({
-                migrate: async (collection, strategy) => {
-                    // @ts-ignore
-                    await engine.migrate(collection, strategy);
-                    migratedCollections.push(collection);
-                },
-                identity: (val) => val,
-                withDefaults: (collectionName, val) => {
-                    return addFieldDefaults(newSchema.collections[collectionName], val);
-                },
-                info: {
-                    changedCollections,
-                    addedCollections,
-                    removedCollections,
-                },
-                queries: engine.queries,
-                mutations: engine.mutations,
-            });
-            const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
-            if (unmigrated.length > 0) {
-                console.error('Unmigrated changed collections:', unmigrated);
-            }
-        },
-        removedCollections,
-        addedIndexes,
-        removedIndexes,
-        allCollections: Object.keys(newSchema.collections),
-        changedCollections,
-        addedCollections,
-        oldCollections: Object.keys(oldSchema.collections),
-        oldSchema,
-        newSchema,
-    };
-}
-export function migrationRange(from, to) {
-    return [...Array(to - from).keys()].map((i) => 1 + i + from);
-}
-function getIndexes(collection) {
-    if (!collection)
-        return [];
-    const fields = Object.keys(collection.fields)
-        .filter((key) => collection.fields[key].indexed)
-        .map((key) => ({
-        name: key,
-        multiEntry: collection.fields[key].type === 'array',
-        synthetic: false,
-        compound: false,
-    }));
-    return [
-        ...fields,
-        ...Object.keys(collection.synthetics || {}).map((key) => ({
-            name: key,
-            multiEntry: ['array', 'string[]', 'number[]', 'boolean[]'].includes(collection.synthetics[key].type),
-            synthetic: true,
-            compound: false,
-        })),
-        ...Object.keys(collection.compounds || {}).map((key) => ({
-            name: key,
-            multiEntry: collection.compounds[key].of.some((fieldName) => (collection.fields[fieldName] || collection.synthetics[fieldName])
-                .type === 'array'),
-            synthetic: false,
-            compound: true,
-        })),
-    ];
-}
-export function createDefaultMigration(schema, newSchema) {
-    let oldSchema = newSchema
-        ? schema
-        : {
-            version: 0,
-            collections: {},
-        };
-    return migrate(oldSchema, newSchema || schema, async ({ migrate, withDefaults, info }) => {
-        if ((newSchema || schema).version === 1)
-            return;
-        for (const collection of info.changedCollections) {
-            // @ts-ignore indefinite type resolution
-            await migrate(collection, (old) => withDefaults(collection, old));
-        }
-    });
-}
+import { stableStringify, addFieldDefaults, } from './index.js';
+const emptySchema = {
+    version: 0,
+    collections: {},
+};
+export function migrate(oldSchemaOrNewSchema, newSchemaOrProcedure, procedureIfTwoSchemas) {
+    const isProcedureSecondArgument = typeof newSchemaOrProcedure === 'function';
+    const oldSchema = isProcedureSecondArgument
+        ? emptySchema
+        : oldSchemaOrNewSchema;
+    const newSchema = isProcedureSecondArgument
+        ? oldSchemaOrNewSchema
+        : newSchemaOrProcedure;
+    const procedure = isProcedureSecondArgument
+        ? newSchemaOrProcedure
+        : procedureIfTwoSchemas;
+    // diff to determine changed collections
+    const changedCollections = Object.keys(newSchema.collections).filter((key) => oldSchema.collections[key] &&
+        stableStringify(oldSchema.collections[key]) !==
+            stableStringify(newSchema.collections[key]));
+    const removedCollections = Object.keys(oldSchema.collections).filter((key) => !newSchema.collections[key]);
+    const addedCollections = Object.keys(newSchema.collections).filter((key) => !oldSchema.collections[key]);
+    const addedIndexes = {};
+    const removedIndexes = {};
+    for (const changed of [...changedCollections, ...addedCollections]) {
+        const oldIndexes = getIndexes(oldSchema.collections[changed]);
+        const newIndexes = getIndexes(newSchema.collections[changed]);
+        const added = newIndexes.filter((index) => !oldIndexes.find((i) => i.name === index.name));
+        const removed = oldIndexes.filter((index) => !newIndexes.find((i) => i.name === index.name));
+        if (added.length > 0) {
+            addedIndexes[changed] = added;
+        }
+        if (removed.length > 0) {
+            removedIndexes[changed] = removed;
+        }
+    }
+    return {
+        version: newSchema.version,
+        migrate: async (engine) => {
+            const migratedCollections = [];
+            await procedure({
+                migrate: async (collection, strategy) => {
+                    // @ts-ignore
+                    await engine.migrate(collection, strategy);
+                    migratedCollections.push(collection);
+                },
+                identity: (val) => val,
+                withDefaults: (collectionName, val) => {
+                    return addFieldDefaults(newSchema.collections[collectionName], val);
+                },
+                info: {
+                    changedCollections,
+                    addedCollections,
+                    removedCollections,
+                },
+                queries: engine.queries,
+                mutations: engine.mutations,
+            });
+            const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
+            if (unmigrated.length > 0) {
+                console.error('Unmigrated changed collections:', unmigrated);
+            }
+        },
+        removedCollections,
+        addedIndexes,
+        removedIndexes,
+        allCollections: Object.keys(newSchema.collections),
+        changedCollections,
+        addedCollections,
+        oldCollections: Object.keys(oldSchema.collections),
+        oldSchema,
+        newSchema,
+    };
+}
+export function migrationRange(from, to) {
+    return [...Array(to - from).keys()].map((i) => 1 + i + from);
+}
+function getIndexes(collection) {
+    if (!collection)
+        return [];
+    const fields = Object.keys(collection.fields)
+        .filter((key) => collection.fields[key].indexed)
+        .map((key) => ({
+        name: key,
+        multiEntry: collection.fields[key].type === 'array',
+        synthetic: false,
+        compound: false,
+    }));
+    return [
+        ...fields,
+        ...Object.keys(collection.synthetics || {}).map((key) => ({
+            name: key,
+            multiEntry: ['array', 'string[]', 'number[]', 'boolean[]'].includes(collection.synthetics[key].type),
+            synthetic: true,
+            compound: false,
+        })),
+        ...Object.keys(collection.compounds || {}).map((key) => ({
+            name: key,
+            multiEntry: collection.compounds[key].of.some((fieldName) => (collection.fields[fieldName] || collection.synthetics[fieldName])
+                .type === 'array'),
+            synthetic: false,
+            compound: true,
+        })),
+    ];
+}
+export function createDefaultMigration(schema, newSchema) {
+    let oldSchema = newSchema
+        ? schema
+        : {
+            version: 0,
+            collections: {},
+        };
+    return migrate(oldSchema, newSchema || schema, async ({ migrate, withDefaults, info }) => {
+        if ((newSchema || schema).version === 1)
+            return;
+        for (const collection of info.changedCollections) {
+            // @ts-ignore indefinite type resolution
+            await migrate(collection, (old) => withDefaults(collection, old));
+        }
+    });
+}
 //# sourceMappingURL=migration.js.map

package/dist/esm/oids.d.ts

@@ -1,87 +1,87 @@
-import { ObjectRef } from './operation.js';
-/**
- * OIDs
- *
- * OIDs are used to identify objects in the document. They also encode
- * information about the object useful to identifying an object found
- * on its own and associating it back to its parent.
- *
- * An OID is structured as such:
- * <collection>/<root id>[/<key paths>]:<random>
- *
- * OIDs have a few characteristics:
- * - They include the collection name of the parent document
- * - They include the primary key of the parent document
- * - They include the key path of the object within the document
- * - They include a random sequence to identify different objects which
- *   exist at the same key path
- *
- * Collection name and document key are used to link any isolated
- * object back to its parent document.
- *
- * The key path is used for authorization - to associate the object
- * (or an operation related to it by OID) with the field it inhabits
- * to utilize authorization rules from that field in the schema.
- *
- * The random sequence allows the application to encode different
- * identities for objects at the same position in a document for
- * conflict resolution purposes
- */
-export declare type ObjectIdentifier = string;
-export declare type KeyPath = (string | number)[];
-export declare const LEGACY_OID_KEY = "__@@oid_do_not_use";
-export declare const OID_KEY = "@@id";
-export declare function getOid(obj: any): string;
-export declare function maybeGetOid(obj: any): ObjectIdentifier | undefined;
-export declare function assignOid(obj: any, oid: ObjectIdentifier): any;
-export declare function hasOid(obj: any): boolean;
-export declare function removeOid(obj: any): any;
-export declare function isOidKey(key: string): boolean;
-/**
- * For sub-objects, assign a random sub-OID if no OID
- * is already assigned.
- */
-export declare function ensureOid(obj: any, rootOid: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
-export declare function createOid(collection: string, documentId: string, keyPath?: KeyPath, subId?: string): string;
-export declare function createSubOid(root: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
-export declare function decomposeOid(oid: ObjectIdentifier): {
-    collection: string;
-    id: string;
-    subId?: string;
-    keyPath: KeyPath;
-};
-export declare function assertAllLevelsHaveOids(obj: any, root?: any): void;
-export declare function assignOidsToAllSubObjects(obj: any, createSubId?: () => string): void;
-export declare function assignOidProperty(obj: any, oid: ObjectIdentifier): any;
-export declare function maybeGetOidProperty(obj: any): any;
-/**
- * Assigns a special property to all objects in the given object
- * which have an OID
- */
-export declare function assignOidPropertiesToAllSubObjects(obj: any): void;
-/**
- *
- * Removes the special property from all objects in the given object
- * which have an OID, transferring the OID from the property to the OID
- * system in-memory.
- */
-export declare function removeOidPropertiesFromAllSubObjects(obj: any): void;
-export declare function removeOidsFromAllSubObjects(obj: any): void;
-export declare function createOidSubId(): string;
-export declare function createRef(oid: ObjectIdentifier): ObjectRef;
-export declare function normalize(obj: any, refs?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
-/**
- * Only normalizes direct children. The created map
- * of objects will still have nested objects.
- */
-export declare function normalizeFirstLevel(obj: any): {
-    refs: Map<string, any>;
-    oidKeyPairs: Map<string, string | number>;
-};
-export declare function getOidRoot(oid: ObjectIdentifier): string;
-/**
- * Returns an inclusive range of OIDs that represent
- * a root object and all of its sub-objects.
- */
-export declare function getOidRange(oid: ObjectIdentifier): string[];
-export declare function getRoots(oids: ObjectIdentifier[]): string[];
+import { ObjectRef } from './operation.js';
+/**
+ * OIDs
+ *
+ * OIDs are used to identify objects in the document. They also encode
+ * information about the object useful to identifying an object found
+ * on its own and associating it back to its parent.
+ *
+ * An OID is structured as such:
+ * <collection>/<root id>[/<key paths>]:<random>
+ *
+ * OIDs have a few characteristics:
+ * - They include the collection name of the parent document
+ * - They include the primary key of the parent document
+ * - They include the key path of the object within the document
+ * - They include a random sequence to identify different objects which
+ *   exist at the same key path
+ *
+ * Collection name and document key are used to link any isolated
+ * object back to its parent document.
+ *
+ * The key path is used for authorization - to associate the object
+ * (or an operation related to it by OID) with the field it inhabits
+ * to utilize authorization rules from that field in the schema.
+ *
+ * The random sequence allows the application to encode different
+ * identities for objects at the same position in a document for
+ * conflict resolution purposes
+ */
+export declare type ObjectIdentifier = string;
+export declare type KeyPath = (string | number)[];
+export declare const LEGACY_OID_KEY = "__@@oid_do_not_use";
+export declare const OID_KEY = "@@id";
+export declare function getOid(obj: any): string;
+export declare function maybeGetOid(obj: any): ObjectIdentifier | undefined;
+export declare function assignOid(obj: any, oid: ObjectIdentifier): any;
+export declare function hasOid(obj: any): boolean;
+export declare function removeOid(obj: any): any;
+export declare function isOidKey(key: string): boolean;
+/**
+ * For sub-objects, assign a random sub-OID if no OID
+ * is already assigned.
+ */
+export declare function ensureOid(obj: any, rootOid: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
+export declare function createOid(collection: string, documentId: string, keyPath?: KeyPath, subId?: string): string;
+export declare function createSubOid(root: ObjectIdentifier, key: string | number, createSubId?: () => string): string;
+export declare function decomposeOid(oid: ObjectIdentifier): {
+    collection: string;
+    id: string;
+    subId?: string;
+    keyPath: KeyPath;
+};
+export declare function assertAllLevelsHaveOids(obj: any, root?: any): void;
+export declare function assignOidsToAllSubObjects(obj: any, createSubId?: () => string): void;
+export declare function assignOidProperty(obj: any, oid: ObjectIdentifier): any;
+export declare function maybeGetOidProperty(obj: any): any;
+/**
+ * Assigns a special property to all objects in the given object
+ * which have an OID
+ */
+export declare function assignOidPropertiesToAllSubObjects(obj: any): void;
+/**
+ *
+ * Removes the special property from all objects in the given object
+ * which have an OID, transferring the OID from the property to the OID
+ * system in-memory.
+ */
+export declare function removeOidPropertiesFromAllSubObjects(obj: any): void;
+export declare function removeOidsFromAllSubObjects(obj: any): void;
+export declare function createOidSubId(): string;
+export declare function createRef(oid: ObjectIdentifier): ObjectRef;
+export declare function normalize(obj: any, refs?: Map<ObjectIdentifier, any>): Map<ObjectIdentifier, any>;
+/**
+ * Only normalizes direct children. The created map
+ * of objects will still have nested objects.
+ */
+export declare function normalizeFirstLevel(obj: any): {
+    refs: Map<string, any>;
+    oidKeyPairs: Map<string, string | number>;
+};
+export declare function getOidRoot(oid: ObjectIdentifier): string;
+/**
+ * Returns an inclusive range of OIDs that represent
+ * a root object and all of its sub-objects.
+ */
+export declare function getOidRange(oid: ObjectIdentifier): string[];
+export declare function getRoots(oids: ObjectIdentifier[]): string[];