@verdant-web/common 1.15.3-next.0 → 1.15.4

package/dist/esm/migration.js

@@ -1,295 +1,295 @@
-import { stableStringify, addFieldDefaults, removeExtraProperties, assert, assignOid, getOid, hasDefault, } 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]);
-    // collections which added one or more field defaults
-    const autoMigratedCollections = new Set();
-    for (const collection of changedCollections) {
-        const oldFields = oldSchema.collections[collection].fields;
-        const newFields = newSchema.collections[collection].fields;
-        // a new default was added - we can auto-migrate it
-        if (Object.keys(newFields).some((key) => { var _a, _b; return !((_a = oldFields[key]) === null || _a === void 0 ? void 0 : _a.default) && ((_b = newFields[key]) === null || _b === void 0 ? void 0 : _b.default); })) {
-            autoMigratedCollections.add(collection);
-        }
-        // a field was removed - we can auto-migrate it
-        if (Object.keys(oldFields).some((key) => !newFields[key])) {
-            autoMigratedCollections.add(collection);
-        }
-    }
-    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;
-            // FIXME: don't o(n^2) this
-            if (changedCollections.includes(changed)) {
-                autoMigratedCollections.add(changed);
-            }
-        }
-        if (removed.length > 0) {
-            removedIndexes[changed] = removed;
-            // FIXME: don't o(n^2) this
-            if (changedCollections.includes(changed)) {
-                autoMigratedCollections.add(changed);
-            }
-        }
-    }
-    const withDefaults = (collectionName, val) => {
-        return addFieldDefaults(newSchema.collections[collectionName], val);
-    };
-    const autoMigration = (collectionName) => (val) => {
-        const collection = newSchema.collections[collectionName];
-        return addFieldDefaults(collection, removeExtraProperties(collection, val));
-    };
-    return {
-        version: newSchema.version,
-        migrate: async (engine) => {
-            const migratedCollections = [];
-            await procedure({
-                migrate: async (collection, strategy) => {
-                    const auto = autoMigration(collection);
-                    const wrapped = async (val) => {
-                        const baseValue = await strategy(val);
-                        // assign OID from original value in case user's strategy
-                        // involves cloning
-                        assignOid(baseValue, getOid(val));
-                        const result = auto(baseValue);
-                        return result;
-                    };
-                    // @ts-ignore
-                    await engine.migrate(collection, wrapped);
-                    migratedCollections.push(collection);
-                    // since the user migrated this one and we wrap their
-                    // strategy with auto-migration, we can remove it from
-                    // the auto-migration list
-                    autoMigratedCollections.delete(collection);
-                },
-                identity: (val) => val,
-                withDefaults,
-                info: {
-                    changedCollections,
-                    addedCollections,
-                    removedCollections,
-                },
-                queries: engine.queries,
-                mutations: engine.mutations,
-            });
-            // mandatory migration of fields which had defaults added or
-            // fields removed but weren't migrated by the user
-            if (newSchema.version > 1) {
-                engine.log('debug', 'auto-migrating collections with new defaults', autoMigratedCollections);
-                for (const name of autoMigratedCollections) {
-                    await engine.migrate(name, autoMigration(name));
-                    migratedCollections.push(name);
-                }
-                const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
-                if (unmigrated.length > 0) {
-                    // TODO: does this deserve a full-on error?
-                    console.error(`Unmigrated changed collections from version ${oldSchema.version} to version ${newSchema.version}:`, 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 [];
-    return [
-        ...Object.keys(collection.indexes || {}).map((key) => ({
-            name: key,
-            multiEntry: ['array', 'string[]', 'number[]', 'boolean[]'].includes(collection.indexes[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.indexes[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, info }) => {
-        if ((newSchema || schema).version === 1)
-            return;
-        for (const collection of info.changedCollections) {
-            // @ts-ignore indefinite type resolution
-            await migrate(collection, (old) => old);
-        }
-    });
-}
-export function createMigration(maybeOldSchema, maybeNewSchemaOrProcedure, maybeProcedure) {
-    const isProcedureSecondArgument = typeof maybeNewSchemaOrProcedure === 'function' ||
-        maybeNewSchemaOrProcedure === undefined;
-    const oldSchema = isProcedureSecondArgument ? emptySchema : maybeOldSchema;
-    const newSchema = isProcedureSecondArgument
-        ? maybeOldSchema
-        : maybeNewSchemaOrProcedure;
-    const procedure = isProcedureSecondArgument
-        ? maybeNewSchemaOrProcedure
-        : maybeProcedure;
-    assert(oldSchema, 'Invalid arguments to createMigration');
-    assert(newSchema, 'Invalid arguments to createMigration');
-    const { changedCollections, addedCollections, removedCollections, addedIndexes, removedIndexes, autoMigratedCollections, autoMigration, } = getMigrationInfo(oldSchema, newSchema);
-    return {
-        version: newSchema.version,
-        migrate: async (engine) => {
-            const migratedCollections = [];
-            const migrate = async (collection, strategy) => {
-                const auto = autoMigration(collection);
-                const wrapped = async (val) => {
-                    const baseValue = await strategy(val);
-                    // assign OID from original value in case user's strategy
-                    // involves cloning
-                    assignOid(baseValue, getOid(val));
-                    const result = auto(baseValue);
-                    return result;
-                };
-                // @ts-ignore
-                await engine.migrate(collection, wrapped);
-                migratedCollections.push(collection);
-                // since the user migrated this one and we wrap their
-                // strategy with auto-migration, we can remove it from
-                // the auto-migration list
-                autoMigratedCollections.delete(collection);
-            };
-            await (procedure === null || procedure === void 0 ? void 0 : procedure({
-                migrate,
-                info: {
-                    changedCollections,
-                    addedCollections,
-                    removedCollections,
-                },
-                queries: engine.queries,
-                mutations: engine.mutations,
-            }));
-            // mandatory migration of fields which had defaults added or
-            // fields removed but weren't migrated by the user
-            if (newSchema.version > 1) {
-                engine.log('debug', 'auto-migrating collections with new defaults', autoMigratedCollections);
-                for (const name of autoMigratedCollections) {
-                    await engine.migrate(name, autoMigration(name));
-                    migratedCollections.push(name);
-                }
-                const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
-                if (unmigrated.length > 0) {
-                    // TODO: does this deserve a full-on error?
-                    console.error(`Unmigrated changed collections from version ${oldSchema.version} to version ${newSchema.version}:`, unmigrated);
-                }
-            }
-        },
-        removedCollections,
-        addedIndexes,
-        removedIndexes,
-        allCollections: Object.keys(newSchema.collections),
-        changedCollections,
-        addedCollections,
-        oldCollections: Object.keys(oldSchema.collections),
-        oldSchema,
-        newSchema,
-    };
-}
-// common tools
-function getMigrationInfo(oldSchema, newSchema) {
-    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]);
-    // collections which added one or more field defaults
-    const autoMigratedCollections = new Set();
-    for (const collection of changedCollections) {
-        const oldFields = oldSchema.collections[collection].fields;
-        const newFields = newSchema.collections[collection].fields;
-        // a new default was added - we can auto-migrate it
-        if (Object.keys(newFields).some((key) => !hasDefault(oldFields[key]) && hasDefault(newFields[key]))) {
-            autoMigratedCollections.add(collection);
-        }
-        // a field was removed - we can auto-migrate it
-        if (Object.keys(oldFields).some((key) => !newFields[key])) {
-            autoMigratedCollections.add(collection);
-        }
-    }
-    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;
-            // FIXME: don't o(n^2) this
-            if (changedCollections.includes(changed)) {
-                autoMigratedCollections.add(changed);
-            }
-        }
-        if (removed.length > 0) {
-            removedIndexes[changed] = removed;
-            // FIXME: don't o(n^2) this
-            if (changedCollections.includes(changed)) {
-                autoMigratedCollections.add(changed);
-            }
-        }
-    }
-    const withDefaults = (collectionName, val) => {
-        return addFieldDefaults(newSchema.collections[collectionName], val);
-    };
-    const autoMigration = (collectionName) => (val) => {
-        const collection = newSchema.collections[collectionName];
-        return addFieldDefaults(collection, removeExtraProperties(collection, val));
-    };
-    return {
-        changedCollections,
-        addedCollections,
-        removedCollections,
-        addedIndexes,
-        removedIndexes,
-        autoMigratedCollections,
-        withDefaults,
-        autoMigration,
-    };
-}
+import { stableStringify, addFieldDefaults, removeExtraProperties, assert, assignOid, getOid, hasDefault, } 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]);
+    // collections which added one or more field defaults
+    const autoMigratedCollections = new Set();
+    for (const collection of changedCollections) {
+        const oldFields = oldSchema.collections[collection].fields;
+        const newFields = newSchema.collections[collection].fields;
+        // a new default was added - we can auto-migrate it
+        if (Object.keys(newFields).some((key) => { var _a, _b; return !((_a = oldFields[key]) === null || _a === void 0 ? void 0 : _a.default) && ((_b = newFields[key]) === null || _b === void 0 ? void 0 : _b.default); })) {
+            autoMigratedCollections.add(collection);
+        }
+        // a field was removed - we can auto-migrate it
+        if (Object.keys(oldFields).some((key) => !newFields[key])) {
+            autoMigratedCollections.add(collection);
+        }
+    }
+    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;
+            // FIXME: don't o(n^2) this
+            if (changedCollections.includes(changed)) {
+                autoMigratedCollections.add(changed);
+            }
+        }
+        if (removed.length > 0) {
+            removedIndexes[changed] = removed;
+            // FIXME: don't o(n^2) this
+            if (changedCollections.includes(changed)) {
+                autoMigratedCollections.add(changed);
+            }
+        }
+    }
+    const withDefaults = (collectionName, val) => {
+        return addFieldDefaults(newSchema.collections[collectionName], val);
+    };
+    const autoMigration = (collectionName) => (val) => {
+        const collection = newSchema.collections[collectionName];
+        return addFieldDefaults(collection, removeExtraProperties(collection, val));
+    };
+    return {
+        version: newSchema.version,
+        migrate: async (engine) => {
+            const migratedCollections = [];
+            await procedure({
+                migrate: async (collection, strategy) => {
+                    const auto = autoMigration(collection);
+                    const wrapped = async (val) => {
+                        const baseValue = await strategy(val);
+                        // assign OID from original value in case user's strategy
+                        // involves cloning
+                        assignOid(baseValue, getOid(val));
+                        const result = auto(baseValue);
+                        return result;
+                    };
+                    // @ts-ignore
+                    await engine.migrate(collection, wrapped);
+                    migratedCollections.push(collection);
+                    // since the user migrated this one and we wrap their
+                    // strategy with auto-migration, we can remove it from
+                    // the auto-migration list
+                    autoMigratedCollections.delete(collection);
+                },
+                identity: (val) => val,
+                withDefaults,
+                info: {
+                    changedCollections,
+                    addedCollections,
+                    removedCollections,
+                },
+                queries: engine.queries,
+                mutations: engine.mutations,
+            });
+            // mandatory migration of fields which had defaults added or
+            // fields removed but weren't migrated by the user
+            if (newSchema.version > 1) {
+                engine.log('debug', 'auto-migrating collections with new defaults', autoMigratedCollections);
+                for (const name of autoMigratedCollections) {
+                    await engine.migrate(name, autoMigration(name));
+                    migratedCollections.push(name);
+                }
+                const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
+                if (unmigrated.length > 0) {
+                    // TODO: does this deserve a full-on error?
+                    console.error(`Unmigrated changed collections from version ${oldSchema.version} to version ${newSchema.version}:`, 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 [];
+    return [
+        ...Object.keys(collection.indexes || {}).map((key) => ({
+            name: key,
+            multiEntry: ['array', 'string[]', 'number[]', 'boolean[]'].includes(collection.indexes[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.indexes[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, info }) => {
+        if ((newSchema || schema).version === 1)
+            return;
+        for (const collection of info.changedCollections) {
+            // @ts-ignore indefinite type resolution
+            await migrate(collection, (old) => old);
+        }
+    });
+}
+export function createMigration(maybeOldSchema, maybeNewSchemaOrProcedure, maybeProcedure) {
+    const isProcedureSecondArgument = typeof maybeNewSchemaOrProcedure === 'function' ||
+        maybeNewSchemaOrProcedure === undefined;
+    const oldSchema = isProcedureSecondArgument ? emptySchema : maybeOldSchema;
+    const newSchema = isProcedureSecondArgument
+        ? maybeOldSchema
+        : maybeNewSchemaOrProcedure;
+    const procedure = isProcedureSecondArgument
+        ? maybeNewSchemaOrProcedure
+        : maybeProcedure;
+    assert(oldSchema, 'Invalid arguments to createMigration');
+    assert(newSchema, 'Invalid arguments to createMigration');
+    const { changedCollections, addedCollections, removedCollections, addedIndexes, removedIndexes, autoMigratedCollections, autoMigration, } = getMigrationInfo(oldSchema, newSchema);
+    return {
+        version: newSchema.version,
+        migrate: async (engine) => {
+            const migratedCollections = [];
+            const migrate = async (collection, strategy) => {
+                const auto = autoMigration(collection);
+                const wrapped = async (val) => {
+                    const baseValue = await strategy(val);
+                    // assign OID from original value in case user's strategy
+                    // involves cloning
+                    assignOid(baseValue, getOid(val));
+                    const result = auto(baseValue);
+                    return result;
+                };
+                // @ts-ignore
+                await engine.migrate(collection, wrapped);
+                migratedCollections.push(collection);
+                // since the user migrated this one and we wrap their
+                // strategy with auto-migration, we can remove it from
+                // the auto-migration list
+                autoMigratedCollections.delete(collection);
+            };
+            await (procedure === null || procedure === void 0 ? void 0 : procedure({
+                migrate,
+                info: {
+                    changedCollections,
+                    addedCollections,
+                    removedCollections,
+                },
+                queries: engine.queries,
+                mutations: engine.mutations,
+            }));
+            // mandatory migration of fields which had defaults added or
+            // fields removed but weren't migrated by the user
+            if (newSchema.version > 1) {
+                engine.log('debug', 'auto-migrating collections with new defaults', autoMigratedCollections);
+                for (const name of autoMigratedCollections) {
+                    await engine.migrate(name, autoMigration(name));
+                    migratedCollections.push(name);
+                }
+                const unmigrated = changedCollections.filter((collection) => !migratedCollections.includes(collection));
+                if (unmigrated.length > 0) {
+                    // TODO: does this deserve a full-on error?
+                    console.error(`Unmigrated changed collections from version ${oldSchema.version} to version ${newSchema.version}:`, unmigrated);
+                }
+            }
+        },
+        removedCollections,
+        addedIndexes,
+        removedIndexes,
+        allCollections: Object.keys(newSchema.collections),
+        changedCollections,
+        addedCollections,
+        oldCollections: Object.keys(oldSchema.collections),
+        oldSchema,
+        newSchema,
+    };
+}
+// common tools
+function getMigrationInfo(oldSchema, newSchema) {
+    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]);
+    // collections which added one or more field defaults
+    const autoMigratedCollections = new Set();
+    for (const collection of changedCollections) {
+        const oldFields = oldSchema.collections[collection].fields;
+        const newFields = newSchema.collections[collection].fields;
+        // a new default was added - we can auto-migrate it
+        if (Object.keys(newFields).some((key) => !hasDefault(oldFields[key]) && hasDefault(newFields[key]))) {
+            autoMigratedCollections.add(collection);
+        }
+        // a field was removed - we can auto-migrate it
+        if (Object.keys(oldFields).some((key) => !newFields[key])) {
+            autoMigratedCollections.add(collection);
+        }
+    }
+    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;
+            // FIXME: don't o(n^2) this
+            if (changedCollections.includes(changed)) {
+                autoMigratedCollections.add(changed);
+            }
+        }
+        if (removed.length > 0) {
+            removedIndexes[changed] = removed;
+            // FIXME: don't o(n^2) this
+            if (changedCollections.includes(changed)) {
+                autoMigratedCollections.add(changed);
+            }
+        }
+    }
+    const withDefaults = (collectionName, val) => {
+        return addFieldDefaults(newSchema.collections[collectionName], val);
+    };
+    const autoMigration = (collectionName) => (val) => {
+        const collection = newSchema.collections[collectionName];
+        return addFieldDefaults(collection, removeExtraProperties(collection, val));
+    };
+    return {
+        changedCollections,
+        addedCollections,
+        removedCollections,
+        addedIndexes,
+        removedIndexes,
+        autoMigratedCollections,
+        withDefaults,
+        autoMigration,
+    };
+}
 //# sourceMappingURL=migration.js.map