joist-orm 1.294.0 → 2.0.1

package/build/newTestInstance.js

@@ -1,738 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.FactoryInitialValue = exports.testIndex = exports.testZonedDateTime = exports.testPlainDateTime = exports.testPlainDate = exports.testDate = void 0;
-exports.newTestInstance = newTestInstance;
-exports.defaultValue = defaultValue;
-exports.noValue = noValue;
-exports.maybeBranchValue = maybeBranchValue;
-exports.maybeNew = maybeNew;
-exports.maybeNewPoly = maybeNewPoly;
-exports.getTestIndex = getTestIndex;
-exports.setFactoryLogging = setFactoryLogging;
-exports.isFactoryCreation = isFactoryCreation;
-exports.resetFactoryCreated = resetFactoryCreated;
-const joist_utils_1 = require("joist-utils");
-const Entity_1 = require("./Entity");
-const EntityManager_1 = require("./EntityManager");
-const EntityMetadata_1 = require("./EntityMetadata");
-const defaults_1 = require("./defaults");
-const keys_1 = require("./keys");
-const FactoryLogger_1 = require("./logging/FactoryLogger");
-const temporal_1 = require("./temporal");
-const utils_1 = require("./utils");
-let logger = undefined;
-// Maybe we should scope this per-em, but assuming tests are single-threaded for now
-let factoryCreated = new WeakSet();
-// Chosen b/c it's a monday https://www.timeanddate.com/calendar/monthly.html?year=2018&month=1&country=1
-const jan1 = new Date(2018, 0, 1);
-exports.testDate = jan1;
-const Temporal = (0, temporal_1.maybeRequireTemporal)()?.Temporal;
-exports.testPlainDate = Temporal?.PlainDate.from("2018-01-01");
-exports.testPlainDateTime = exports.testPlainDate?.toPlainDateTime("00:00:00");
-exports.testZonedDateTime = exports.testPlainDate?.toZonedDateTime("UTC");
-const knownUseKeys = ["use", "useLogging", "useExistingCheck", "useFactoryDefaults"];
-/**
- * Creates a test instance of `T`.
- *
- * If the factory code passes factoryOpts.useExisting, they can "intercept" the `em.create`
- * to try and resolve "already created" / singleton instances. The `useExisting` callback is
- * useful b/c the `opts` will be the "resolved-to-entity" opts, and not the raw "maybe object
- * literal, maybe object instance" opts that tests pass into the factory.
- */
-function newTestInstance(em, cstr, 
-/** The test's test-specific override opts. */
-testOpts = {}, 
-/** The factory file's default opts. */
-factoryOpts = {}) {
-    // The first factory that is asked to debug, without one in place, will create+unset the logger.
-    let ownsTheLogger = !logger && testOpts.useLogging;
-    if (ownsTheLogger)
-        logger = new FactoryLogger_1.FactoryLogger();
-    logger?.logCreating(cstr);
-    logger?.indent();
-    const meta = (0, EntityMetadata_1.getMetadata)(cstr);
-    const opts = mergeOpts(meta, testOpts, factoryOpts);
-    const use = getOrCreateUseMap(opts);
-    const selfFields = [];
-    // Create just the primitive and m2o fields 1st, so we can create a minimal/valid
-    // instance of the entity. We'll do the o2m/other fields as a second pass.
-    const initialOpts = Object.values(meta.allFields)
-        .map((field) => {
-        const { fieldName } = field;
-        // Don't fill in required fields if told not to
-        const ignoreAllDefaults = "useFactoryDefaults" in opts && opts.useFactoryDefaults === "none";
-        // If the field has a default value, don't force fill it, even if passed `author: undefined`
-        const required = field.required && !ignoreAllDefaults && !(0, defaults_1.hasDefaultValue)(meta, fieldName);
-        // Use the opts value if they passed one in
-        if (fieldName in opts && opts[fieldName] !== defaultValueMarker) {
-            const optValue = opts[fieldName];
-            // We don't explicitly support null (callers should pass undefined), but we accept it
-            // because the factory might have done `const { author, ... } = opts` and is accidentally
-            // passing an `author: undefined` without meaning too.
-            const shouldRespectUndefined = !required;
-            if (optValue === null || (optValue === undefined && shouldRespectUndefined)) {
-                return [];
-            }
-            switch (field.kind) {
-                case "m2o":
-                case "poly":
-                    return [fieldName, resolveFactoryOpt(em, opts, field, optValue, undefined, undefined)];
-                case "o2o":
-                case "o2m":
-                case "m2m":
-                    // We do these in the 2nd pass after `entity` exists (see additionalOpts)
-                    return [];
-                case "lo2m":
-                    // If a child is passing themselves into a parent that is a large collection, just ignore it
-                    return [];
-                case "primitive":
-                case "enum":
-                case "primaryKey":
-                    // Look for strings that want to use the test index
-                    if (typeof optValue === "string" && optValue.includes(testIndexString)) {
-                        const actualIndex = getTestIndex(em, meta.cstr);
-                        const value = optValue.replace(testIndexString, String(actualIndex));
-                        return [fieldName, value];
-                    }
-                    else if (typeof optValue === "number" && optValue === exports.testIndex) {
-                        const actualIndex = getTestIndex(em, meta.cstr);
-                        return [fieldName, actualIndex];
-                    }
-                    // Otherwise just use the user's opt value as-is
-                    return [fieldName, optValue];
-                default:
-                    return (0, utils_1.assertNever)(field);
-            }
-        }
-        if (field.kind === "primitive" &&
-            (required || opts[fieldName] === defaultValueMarker) &&
-            !field.derived &&
-            !field.protected) {
-            return [fieldName, defaultValueForField(em, cstr, field)];
-        }
-        else if (field.kind === "m2o" && !field.derived) {
-            // If neither the user nor the factory (i.e. for an explicit "fan out" case) set this field,
-            // then look in `use` and for an "obvious" there-is-only-one default (even for optional fields)
-            const [existing, loggerKey] = getObviousDefault(em, field.otherMetadata(), use);
-            // If this is a m2o pointing to an o2o, i.e. that as a unique constraint, make sure the
-            // existing entity we found isn't already claimed
-            const isUniqueAndAlreadyUsed = existing &&
-                (0, EntityMetadata_1.isOneToOneField)(field.otherMetadata().allFields[field.otherFieldName]) &&
-                existing[field.otherFieldName].isLoaded &&
-                existing[field.otherFieldName].isSet;
-            if (existing && !isUniqueAndAlreadyUsed && !ignoreAllDefaults) {
-                logger?.[loggerKey](fieldName, existing);
-                return [fieldName, existing];
-            }
-            // Otherwise, only make a new entity only if the field is required
-            if (required) {
-                // ...unless this is a self-referential key, in which case avoid infinite looping.
-                if (field.otherMetadata() === meta) {
-                    selfFields.push(fieldName);
-                    return [];
-                }
-                else {
-                    return [fieldName, resolveFactoryOpt(em, opts, field, undefined, undefined, undefined)];
-                }
-            }
-        }
-        else if (field.kind === "enum" && required && !field.derived) {
-            return [fieldName, field.enumDetailType.getValues()[0]];
-        }
-        else if (field.kind === "poly" && required) {
-            return [fieldName, resolveFactoryOpt(em, opts, field, undefined, undefined, undefined)];
-        }
-        return [];
-    })
-        .filter((t) => t.length > 0);
-    const createOpts = Object.fromEntries(initialOpts);
-    if (factoryOpts.useExisting && testOpts.useExistingCheck !== false) {
-        const existing = em.entities
-            .filter((e) => e instanceof meta.cstr)
-            .find((e) => factoryOpts.useExisting(createOpts, e));
-        if (existing) {
-            logger?.logFoundExisting(existing);
-            logger?.dedent();
-            if (ownsTheLogger)
-                logger = undefined;
-            return existing;
-        }
-    }
-    const entity = em.create(cstr, createOpts);
-    // Report this as factory-created until the next em.flush
-    factoryCreated.add(entity);
-    // If the type we just made doesn't exist in `use` yet, remember it. This works better than
-    // looking at the values in `fullOpts`, because instead of waiting until the end of the
-    // `build fullOpts` loop, we're also invoking `newTestInstance` as we go through the loop itself,
-    // creating each test instance within nested/recursive `newTestInstance` calls.
-    if (!use.has(entity.constructor) || use.get(entity.constructor)[1] === "diffBranch") {
-        addToUseMap(use, entity, "sameBranch");
-    }
-    else {
-        // The `addToUseMap` does its own 'created & added to scope'
-        logger?.logCreated(entity);
-    }
-    // Now that we've got the entity, do a 2nd pass for o2m/m2m where we pass
-    // `{ parent: entity }` down to children (i.e. to replace our original
-    // null marker approach).
-    const additionalOpts = Object.entries(opts).map(([fieldName, optValue]) => {
-        const field = meta.allFields[fieldName];
-        // Look for `use` / etc
-        if (knownUseKeys.includes(fieldName))
-            return [];
-        if (!field) {
-            // Look for extra/derived fields
-            if (fieldName.startsWith("with")) {
-                const realName = fieldName[4].toLowerCase() + fieldName.substring(5);
-                const realField = meta.allFields[realName];
-                if (realField && "derived" in realField && realField.derived === "async") {
-                    return [realName, new FactoryInitialValue(optValue)];
-                }
-            }
-            throw new Error(`Unknown field ${fieldName}`);
-        }
-        if (optValue === null || optValue === undefined)
-            return [];
-        if (field.kind === "o2m") {
-            // If this is a list of children, i.e. book.authors, handle partials to newTestInstance'd
-            return [
-                fieldName,
-                optValue.map((opt, i) => {
-                    // console.log(`${field.fieldName}`, i);
-                    return resolveFactoryOpt(em, withBranchMap(opts), field, opt, entity, i);
-                }),
-            ];
-        }
-        else if (field.kind == "m2m") {
-            return [
-                fieldName,
-                optValue.map((opt, i) => resolveFactoryOpt(em, withBranchMap(opts), field, opt, [entity], i)),
-            ];
-        }
-        else if (field.kind === "o2o") {
-            const otherField = field.otherMetadata().allFields[field.otherFieldName];
-            const isReactiveReference = "derived" in otherField && otherField.derived === "async";
-            if (isReactiveReference)
-                return [];
-            // If this is an o2o, i.e. author.image, just pass the optValue (i.e. it won't be a list)
-            return [fieldName, resolveFactoryOpt(em, opts, field, optValue, entity, undefined)];
-        }
-        else {
-            return []; // Assume createOpts handled this
-        }
-    });
-    for (const fieldName of selfFields) {
-        additionalOpts.push([fieldName, entity]);
-    }
-    entity.set(Object.fromEntries(additionalOpts.filter((t) => t.length > 0)));
-    // em.create applied synchronous defaults automatically; since we're a factory with likely
-    // deeply-loaded instances, go ahead and synchronously invoke the async defaults, at least
-    // the ones that just use load hints + a synchronous lambda.
-    // (...would be nice to log these in the setFactoryLogging output)
-    (0, defaults_1.setAsyncDefaultsSynchronously)(em.ctx, entity);
-    // Set it back to undefined
-    logger?.dedent();
-    if (ownsTheLogger)
-        logger = undefined;
-    return entity;
-}
-/**
- * Resolves a `FactoryEntityOpt` (i.e. maybe an existing entity, maybe an id, maybe a hash of opts) to an entity.
- *
- * If `opt` is `undefined`, then the usual factory semantics of "check use", "look for only one instance" are
- * checked before finally creating a brand new entity.
- *
- * We also accept an optional `otherFieldName` so that, if we do create a new entity, we pass along the null
- * marker for them to know not to create their own version of us.
- *
- * (This was originally intended to be a public API, but the use case ended up being handled
- * by the more-ergonomic `maybeNew` feature; we could explore making this public if another
- * similar use case comes up in the future.)
- */
-function resolveFactoryOpt(em, opts, field, opt, maybeEntity, fieldIndex) {
-    const use = getOrCreateUseMap(opts);
-    const { meta, otherFieldName } = metaFromFieldAndOpt(field, opt);
-    // const meta = field.kind === "poly" ? field.components[0].otherMetadata() : field.otherMetadata();
-    // const otherFieldName = field.kind === "poly" ? field.components[0].otherFieldName : field.otherFieldName;
-    const fieldWithIndex = `${field.fieldName}${fieldIndex !== undefined ? `[${fieldIndex}]` : ""}`;
-    if ((0, Entity_1.isEntity)(opt)) {
-        logger?.logFoundOpt(fieldWithIndex, opt);
-        return opt;
-    }
-    else if ((0, EntityManager_1.isId)(opt)) {
-        // Try finding the entity in the UoW, otherwise fallback on just setting it as the id (which we support that now)
-        const found = em.entities.find((e) => e.idTaggedMaybe === opt || getTestId(em, e) === opt) || opt;
-        logger?.logFoundOpt(fieldWithIndex, found);
-        return found;
-    }
-    else if (opt && !(0, joist_utils_1.isPlainObject)(opt) && !(opt instanceof MaybeNew)) {
-        // If opt isn't a POJO, assume this is a completely-custom factory
-        logger?.logNotFoundAndCreating(fieldWithIndex, meta);
-        return meta.factory(em, opt);
-    }
-    else {
-        // Look for an obvious default
-        if (opt === undefined || opt instanceof MaybeNew) {
-            if (field.kind === "poly" ||
-                (field.otherMetadata().subTypes.length > 0 && opt instanceof MaybeNew && opt.polyRefPreferredOrder.length > 0)) {
-                // We have a polymorphic maybeNew to sort through
-                const [existing, loggerKey] = (opt instanceof MaybeNew
-                    ? opt.polyRefPreferredOrder.map((cstr) => (0, EntityMetadata_1.getMetadata)(cstr))
-                    : field.kind === "poly"
-                        ? field.components.map((c) => c.otherMetadata())
-                        : [meta])
-                    .map((meta) => getObviousDefault(em, meta, use))
-                    .find((existing) => !!existing[0]) || [undefined, undefined];
-                if (existing) {
-                    logger?.[loggerKey](fieldWithIndex, existing);
-                    return existing;
-                }
-            }
-            else {
-                // Otherwise fall though to making a new entity via the factory
-                const [existing, loggerKey] = getObviousDefault(em, meta, use);
-                if (existing) {
-                    logger?.[loggerKey](fieldWithIndex, existing);
-                    return existing;
-                }
-            }
-        }
-        // If this is image.author (m2o) but the other-side is an o2o, pass null instead of []
-        maybeEntity ??= (meta.allFields[otherFieldName].kind === "o2o" ? null : []);
-        logger?.logNotFoundAndCreating(fieldWithIndex, meta);
-        return meta.factory(em, {
-            // Because of the `!isPlainObject` above, opt will either be undefined or an object here
-            ...applyUse(opt || {}, use, meta),
-            ...(opt instanceof MaybeNew && opt.opts),
-            [otherFieldName]: maybeEntity,
-        });
-    }
-}
-/** Determines the metadata and otherFieldName to use in resolveFactoryOpt to account for polymorphic fields */
-function metaFromFieldAndOpt(field, opt) {
-    if (field.kind === "poly") {
-        let componentToUse = 
-        // Otherwise, we check if the `opt` specifies a particular component to use, and if not fall back to the first one
-        field.components.find((component) => opt instanceof MaybeNew &&
-            (0, EntityMetadata_1.getBaseSelfAndSubMetas)(component.otherMetadata())
-                .map((m) => m.cstr)
-                .includes(opt.polyRefPreferredOrder[0])) ?? field.components[0];
-        return { meta: componentToUse.otherMetadata(), otherFieldName: componentToUse.otherFieldName };
-    }
-    else if (field.otherMetadata().subTypes.length > 0 &&
-        opt instanceof MaybeNew &&
-        opt.polyRefPreferredOrder.length > 0) {
-        const otherMeta = field.otherMetadata();
-        const types = (0, EntityMetadata_1.getBaseSelfAndSubMetas)(otherMeta);
-        const typeToUse = types.find((subType) => subType.cstr === opt.polyRefPreferredOrder[0]) ?? otherMeta;
-        return { meta: typeToUse, otherFieldName: field.otherFieldName };
-    }
-    else {
-        // If it isn't a poly field, then the field itself can tell us everything we need to know
-        return { meta: field.otherMetadata(), otherFieldName: field.otherFieldName };
-    }
-}
-/** We look for `use`-cached entities, which are either those we created, or had "if-only-one" defaults. */
-function getObviousDefault(em, metadata, use) {
-    if (use.has(metadata.cstr)) {
-        return [use.get(metadata.cstr)[0], "logFoundInUseMap"];
-    }
-    // If there is a single existing instance of this type, assume the caller is fine with that.
-    // ...in theory seeding our `use` map with the only-one entities was supposed to prevent the
-    // need for doing this (the entities would already be in the use map that we just checked),
-    // but that approach doesn't catch created-as-side-effect entities.
-    const existing = em.getEntities(metadata.cstr);
-    if (existing.length === 1) {
-        return [existing[0], "logFoundSingleEntity"];
-    }
-    return [undefined, undefined];
-}
-// When a factory is called, i.e. `newAuthor`, opts will:
-//
-// - Have values explicitly passed by the user/other factories
-// - Have values from the user's explicit `use` parameter
-// - NOT have guessed (i.e. "only existing entity") or an implicitly-created `use` parameter
-//
-// This allows the factory to "fan out" by default, i.e. newInternalUser creating its own User
-// and Market creating its own ProductAttribute, which originally we couldn't do when
-// guessed/implicit opts were passed directly to `newAuthor`.
-//
-// Now, if the `newAuthor` factory doesn't explicitly "fan out" (by passing `user: {}` to
-// `newTestInstance`), we still "fan in" by having `newTestInstance` sneak in the guessed/implicit
-// opts of only-one-existing or factory-created instances.
-/** Given we're going to call a factory, make sure any `use`s are put into `opts`. */
-function applyUse(optsMaybeNew, use, metadata) {
-    const opts = optsMaybeNew instanceof MaybeNew ? optsMaybeNew.opts : optsMaybeNew;
-    // Find any unset fields
-    Object.values(metadata.fields)
-        .filter((f) => !(f.fieldName in opts))
-        .forEach((f) => {
-        // And set them to the current `use` entity for their type, if it exists
-        if ((((0, EntityMetadata_1.isManyToOneField)(f) && !f.derived) || (0, EntityMetadata_1.isOneToOneField)(f)) && use.has(f.otherMetadata().cstr)) {
-            const def = use.get(f.otherMetadata().cstr);
-            // Only pass explicit/user-defined `use` entities, so that factories can "fan out" if they want,
-            // and not see other factory-created entities look like user-specific values.
-            if (def[1] === "useOpt") {
-                opts[f.fieldName] = def[0];
-            }
-        }
-    });
-    // Make a copy so that we don't leak `use` onto opts that tests might later use in assertions.
-    return { ...opts, use };
-}
-/**
- * A marker value for later replacement with the test instance's "unique-ish" index.
- *
- * This is meant to just be a helpful identifier in fields like entity names/descriptions for
- * debugging purposes.
- */
-exports.testIndex = -1_111_111_222;
-const testIndexString = String(exports.testIndex);
-const defaultValueMarker = {};
-const branchValueSym = Symbol("branchValue");
-/**
- * A marker value for the default `newTestInstance` behavior.
- *
- * Useful for passing arguments to `newTestInstance` where you sometimes want to
- * provide a specific value, and other times ask for the "pick a default" behavior
- * (i.e. you don't want to pass `undefined` b/c that means explicitly "leave this
- * key unset").
- *
- * Note that this is a function so that we can infer the return type as basically
- * `any` without really using `any` (which would disable type-checking in the rest
- * of the expression).
- */
-function defaultValue() {
-    return defaultValueMarker;
-}
-/**
- * A marker value to never set a field, even if it's required.
- *
- * The factories treat `{ author: undefined }` as "still set the author", because of how easy
- * it is for destructuring/restructuring opts to implicitly set `undefined` values.
- *
- * If you want to force a field to not be set, you can use `{ author: noValue() }`.
- */
-function noValue() {
-    return null;
-}
-/**
- * A marker value to accept values only if explicitly created-or-passed within the current,
- * unique "branch" of a factory call.
- *
- * This is useful for "diamond-shape" entity models like:
- *
- * ```
- *  ParentGroup <-- ParentItem
- *      |              |
- *   ChildGroup  <-- ChildItem
- * ```
- *
- * Where it's important that the `ChildItem -> ParentItem -> ParentGroup` path matches
- * the `ChildItem -> ChildGroup -> ParentGroup` path.
- *
- * This can be hard to achieve in normal factory behavior, i.e. for a call like:
- *
- * ```ts
- * const c = newChild(em, {
- *   groups: [
- *     { childItems: [{}, {}] },
- *     { childItems: [{}, {}] },
- *   ],
- * });
- * ```
- *
- * The first `ChildGroup` will create a new `ParentGroup` that is used by everything, which
- * is not our intent, as both `ChildGroup`s, and all four `ParentItem`s, will live in a single
- * `ParentGroup`.
- *
- * An initial idea is to pass `parentGroup: {}` in the factories, because that turns off "reusing
- * existing instances", but for this problem the `{}` approach is "too good" at creating new
- * instances, b/c the above diamond pattern will be disconnected.
- *
- * So `branchValue` provides a middle ground, where _usually_ it will be a new entity, unless
- * it was explicitly created within the same "branch" of a factory call.
- */
-function maybeBranchValue(opts) {
-    // opts get mutated, so we have to return a new value
-    return { [branchValueSym]: true, ...(opts ? opts : undefined) };
-}
-/**
- * Allows a factory to declare that an optional relation should be filled in with an
- * "obvious default", or a new entity if one doesn't exist.
- *
- * This "obvious default or new entity" is what Joist already does for _required_ relations,
- * and so `maybeNew` lets the factory tell Joist to apply the same behavior to an optional
- * field.
- *
- * I.e.:
- *
- * ```typescript
- * export function newAuthor(em: Entity, opts: FactoryOpts<Author>) {
- *   return newTestInstance(em, Author, {
- *     // this always make a new publisher, unless explicitly overridden by the test,
- *     // i.e. when each author really needs "their own" publisher.
- *     publisher: {},
- *     // this will make a new publisher but first looks for "good defaults" in the
- *     // test, i.e. an already-created publisher. This is the default behavior of
- *     // required fields ("look for a good default"), and `maybeNew` lets you tell
- *     // Joist to invoke that same "maybe new" behavior for an optional field.
- *     publisher: maybeNew<Publisher>({}),
- *     ...opts,
- *   });
- * }
- * ```
- */
-function maybeNew(opts) {
-    // Return a marker that resolveFactoryOpt will look for
-    return new MaybeNew((opts || {}));
-}
-/**
- * Similar to `maybeNew` in behaviour/use but with enhancements to support polymorphic fields:
- * 1) Allows you to specify which entity type to create, if it is found a new one is needed
- * 2) Allows you to prioritize which existing entities to select
- *
- * For example below, we are specifying that an Author should be created if needed (and optionally it's default opts
- * in the `ifNewOpts` field), and also that the priority order for choosing existing entities is Author, Book, and then Publisher.
- * Note since BookReview is excluded from `existingSearchOrder`, an existing BookReview will never be chosen.
- *
- * ```typescript
- * export function newComment(em: EntityManager, opts: FactoryOpts<Comment> = {}): New<Comment> {
- *   return newTestInstance(em, Comment, {
- *     parent: maybeNewPoly<CommentParent, Author>(
- *       Author, {
- *         ifNewOpts: { firstName: "optional"},
- *         existingSearchOrder: [Author, Book, Publisher]
- *       }),
- *     ...opts,
- *   });
- * }
- * ```
- */
-function maybeNewPoly(ifNewCstr, opts) {
-    // Return a marker that resolveFactoryOpt will look for
-    return new MaybeNew((opts?.ifNewOpts || {}), opts?.existingSearchOrder ?? [ifNewCstr]);
-}
-class MaybeNew {
-    opts;
-    polyRefPreferredOrder;
-    constructor(opts, polyRefPreferredOrder = []) {
-        this.opts = opts;
-        this.polyRefPreferredOrder = polyRefPreferredOrder;
-    }
-}
-/**
- * Returns a unique-ish test index for putting in `name` fields.
- *
- * Note that `testIndex` is easier to just include in a string, because it doesn't require passing
- * the `EntityManger` and `type`. But if a factory really wants the test index as a number, they can
- * call this method.
- *
- * Despite the name, these are 1-based, i.e. the first `Author` is `a1`.
- */
-function getTestIndex(em, type) {
-    const existing = em.getEntities(type);
-    return existing.length + 1;
-}
-/** Fakes a probably-right id for un-persisted entities. Solely used for quick lookups in tests/factories. */
-function getTestId(em, entity) {
-    const meta = (0, EntityMetadata_1.getMetadata)(entity);
-    const sameType = em.getEntities(meta.cstr);
-    return (0, keys_1.tagId)(meta, String(sameType.indexOf(entity) + 1));
-}
-// We keep a local copy of `global.Date`, in case a faking library
-// like @sinonjs/fake-timers is used and rewrites `global.Date` to
-// their own `ClockDate`, which would make our `===` check below fail.
-const globalDate = global.Date;
-function defaultValueForField(em, cstr, field) {
-    if (field.serde.columns[0].isArray)
-        return [];
-    if (field.type === "string") {
-        if (field.fieldName === "name") {
-            return `${cstr.name} ${getTestIndex(em, cstr)}`;
-        }
-        return field.fieldName;
-    }
-    else if (field.type === "number") {
-        return 0;
-    }
-    else if (field.type === "bigint") {
-        return 0n;
-    }
-    else if (field.type === globalDate) {
-        return exports.testDate;
-    }
-    else if (field.type === "boolean") {
-        return false;
-    }
-    else if (Temporal) {
-        if (field.type === Temporal.PlainDate) {
-            return exports.testPlainDate;
-        }
-        else if (field.type === Temporal.PlainDateTime) {
-            return exports.testPlainDateTime;
-        }
-        else if (field.type === Temporal.ZonedDateTime) {
-            return exports.testZonedDateTime;
-        }
-    }
-    return null;
-}
-// Do a one-time conversion of the user's `use` array into a map for internal use, which we'll
-// then re-use across all `newTestInstance` calls within a given `new<Entity>` call.
-function getOrCreateUseMap(opts) {
-    const use = opts.use;
-    let map;
-    if (use instanceof Map) {
-        // it's already a map
-        map = use;
-    }
-    else {
-        map = new Map();
-        if (use instanceof Array) {
-            // it's a top-level `newAuthor` with a user-passed `use: array`
-            use.forEach((e) => addToUseMap(map, e, "useOpt"));
-        }
-        else if (use) {
-            // it's a top-level `newAuthor` w/o a `use: entity` param
-            addToUseMap(map, use, "useOpt");
-        }
-        // Scan opts for entities to add to the map, i.e. if the user calls `newAuthor(em, { book: b1 })`,
-        // we'll use `b1` for any other books we might happen to create.
-        const todo = [opts];
-        while (todo.length > 0) {
-            const opts = todo.pop();
-            for (const opt of Object.values(opts || {})) {
-                if ((0, Entity_1.isEntity)(opt) && !map.has(opt.constructor)) {
-                    addToUseMap(map, opt, "testOpts");
-                }
-                else if (opt instanceof Array) {
-                    // Push the array as-is, because it will be `Object.value`-d on the next iteration
-                    todo.push(opt);
-                }
-                else if ((0, joist_utils_1.isPlainObject)(opt)) {
-                    todo.push(opt);
-                }
-            }
-        }
-    }
-    // Store our potentially-massaged map back into opts i.e. in case resolveFactoryOpt needs it.
-    // Use as any b/c UseMap is our internal impl detail and not public.
-    opts.use = map;
-    return map;
-}
-// If e is a subtype like SmallPublisher, register it for the base Publisher as well
-function addToUseMap(map, e, source) {
-    logger?.logAddToUseMap(e, source);
-    const meta = (0, EntityMetadata_1.getMetadata)(e);
-    if (meta.baseType || meta.subTypes.length) {
-        (0, EntityMetadata_1.getBaseAndSelfMetas)(meta).forEach((m) => {
-            // console.log(`Putting ${e.toString()} into ${objectId(map)} as ${source}`);
-            map.set(m.cstr, [e, source]);
-        });
-    }
-    else {
-        // console.log(`Putting ${e.toString()} into ${objectId(map)} as ${source}`);
-        map.set(meta.cstr, [e, source]);
-    }
-}
-/** Merge the factory's opts and the test's opts so that `{ age: 40 }` and `{ firstName: "b1" }` get merged. */
-function mergeOpts(meta, testOpts, factoryOpts) {
-    // Merge the factory's opts and the test's opts so that `{ age: 40 }` and `{ firstName: "b1" }` get merged
-    if (testOpts.useFactoryDefaults === false || testOpts.useFactoryDefaults === "none") {
-        return testOpts;
-    }
-    const opts = { ...testOpts };
-    Object.entries(factoryOpts).forEach(([key, factoryValue]) => {
-        // Skip special opts
-        if (key === "useExisting")
-            return;
-        const testValue = testOpts[key];
-        if (testOpts[key] === undefined) {
-            // If the test doesn't define an opt, we have nothing to merge...unless
-            // they literally passed `foo: undefined`, in which case they win.
-            if (!(key in testOpts)) {
-                opts[key] = factoryValue;
-            }
-        }
-        else if ((0, joist_utils_1.isPlainObject)(factoryValue) && (0, joist_utils_1.isPlainObject)(testValue)) {
-            // Should this deep merge? Probably?
-            opts[key] = mergeOpts(meta, testValue, factoryValue);
-        }
-        else if (factoryValue instanceof MaybeNew && (0, joist_utils_1.isPlainObject)(testValue)) {
-            opts[key] = mergeOpts(meta, testValue, factoryValue.opts);
-        }
-        else if (factoryValue instanceof MaybeNew && testValue instanceof MaybeNew) {
-            opts[key] = new MaybeNew(mergeOpts(meta, testValue.opts, factoryValue.opts), testValue.polyRefPreferredOrder ?? factoryValue.polyRefPreferredOrder);
-        }
-        // This seemed like a good idea
-        if (opts[key]?.[branchValueSym]) {
-            const field = meta.allFields[key];
-            if (field.kind === "m2o") {
-                const use = testOpts.use;
-                const inTree = use?.get(field.otherMetadata().cstr);
-                if (inTree && (inTree[1] === "sameBranch" || inTree[1] === "testOpts")) {
-                    // console.log(`Putting ${field.fieldName} to`, inTree[0]);
-                    opts[key] = inTree[0];
-                }
-            }
-            else {
-                throw new Error(`branchValue is not implemented for ${field.kind}`);
-            }
-            delete opts[key]?.[branchValueSym];
-        }
-    });
-    return opts;
-}
-// As we branch out to children, going down the tree, give each branch its own playground of entities
-function withBranchMap(opts) {
-    const oldMap = opts.use;
-    const newMap = new CopyMap(oldMap);
-    return { ...opts, use: newMap };
-}
-/** Writes new entities into our branch's map (this map), as well as the root we came from. */
-class CopyMap extends Map {
-    root;
-    constructor(root) {
-        super(root);
-        this.root = root;
-    }
-    set(k, v) {
-        // Purposefully downgrade this to source=diffBranch so that it will not be used by `branchValue()`
-        // calls that override `{}`, but can still be used to in-fan, i.e. if making multiple books by
-        // default they get the same author.
-        // ...also use `root?` because the `super(root)` will call `set` while copying the other map
-        // but our `this.root` has not been set yet; which is fine, we want to ignore those anyway.
-        this.root?.set(k, [v[0], "diffBranch"]);
-        return super.set(k, v);
-    }
-}
-// const objectId = (() => {
-//   let currentId = 0;
-//   const map = new WeakMap();
-//   return (object: object): number => {
-//     if (!map.has(object)) {
-//       map.set(object, ++currentId);
-//     }
-//     return map.get(object)!;
-//   };
-// })();
-/** Enables factory logging for all factories. */
-function setFactoryLogging(enabled) {
-    logger = enabled ? new FactoryLogger_1.FactoryLogger() : undefined;
-}
-/** Marker for tests setting derived values during test setup. */
-class FactoryInitialValue {
-    value;
-    constructor(value) {
-        this.value = value;
-    }
-}
-exports.FactoryInitialValue = FactoryInitialValue;
-function isFactoryCreation(entity) {
-    return factoryCreated.has(entity);
-}
-function resetFactoryCreated() {
-    factoryCreated = new WeakSet();
-}
-//# sourceMappingURL=newTestInstance.js.map