joist-core 2.3.0-next.7 → 2.3.0-next.71

package/build/index.cjs

@@ -0,0 +1,515 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_columns = require("./columns.cjs");
+const require_scopes = require("./scopes.cjs");
+require("./typeMap.cjs");
+const require_EntityFilter = require("./EntityFilter.cjs");
+const require_EntityGraphQLFilter = require("./EntityGraphQLFilter.cjs");
+const require_keywords = require("./keywords.cjs");
+const require_relations_Collection = require("./relations/Collection.cjs");
+const require_getProperties = require("./getProperties.cjs");
+const require_newEntity = require("./newEntity.cjs");
+const require_relations_AbstractRelationImpl = require("./relations/AbstractRelationImpl.cjs");
+const require_relations_CustomCollection = require("./relations/CustomCollection.cjs");
+const require_relations_EnumCollection = require("./relations/EnumCollection.cjs");
+const require_relations_CustomReference = require("./relations/CustomReference.cjs");
+const require_relations_hasAsyncMethod = require("./relations/hasAsyncMethod.cjs");
+const require_relations_RecursiveCycleError = require("./relations/RecursiveCycleError.cjs");
+const require_relations_hasProperty = require("./relations/hasProperty.cjs");
+const require_relations_AsyncProperty = require("./relations/AsyncProperty.cjs");
+const require_RowData = require("./RowData.cjs");
+const require_relations_LazyField = require("./relations/LazyField.cjs");
+const require_relations_hasManyDerived = require("./relations/hasManyDerived.cjs");
+const require_relations_hasManyThrough = require("./relations/hasManyThrough.cjs");
+const require_relations_Reference = require("./relations/Reference.cjs");
+const require_relations_hasOneDerived = require("./relations/hasOneDerived.cjs");
+const require_relations_hasOneThrough = require("./relations/hasOneThrough.cjs");
+const require_relations_ManyToManyCollection = require("./relations/ManyToManyCollection.cjs");
+const require_relations_Relation = require("./relations/Relation.cjs");
+const require_relations_ManyToManyLargeCollection = require("./relations/ManyToManyLargeCollection.cjs");
+const require_relations_OneToManyCollection = require("./relations/OneToManyCollection.cjs");
+const require_relations_ManyToOneReference = require("./relations/ManyToOneReference.cjs");
+const require_relations_OneToManyLargeCollection = require("./relations/OneToManyLargeCollection.cjs");
+const require_relations_ReactiveReference = require("./relations/ReactiveReference.cjs");
+const require_relations_OneToOneReference = require("./relations/OneToOneReference.cjs");
+const require_relations_PolymorphicReference = require("./relations/PolymorphicReference.cjs");
+const require_relations_ReactiveField = require("./relations/ReactiveField.cjs");
+const require_relations_ReactiveGetter = require("./relations/ReactiveGetter.cjs");
+const require_relations_ReactiveManyToMany = require("./relations/ReactiveManyToMany.cjs");
+const require_Todo = require("./Todo.cjs");
+const require_logging_ReactionLogger = require("./logging/ReactionLogger.cjs");
+const require_trusted = require("./trusted.cjs");
+const require_JoinRows = require("./JoinRows.cjs");
+const require_relations_ReactiveManyToManyOtherSide = require("./relations/ReactiveManyToManyOtherSide.cjs");
+const require_relations_AsyncReactiveField = require("./relations/AsyncReactiveField.cjs");
+const require_relations_RecursiveCollection = require("./relations/RecursiveCollection.cjs");
+const require_relations_ReadOnlyCollection = require("./relations/ReadOnlyCollection.cjs");
+require("./relations/index.cjs");
+const require_keys = require("./keys.cjs");
+const require_fieldSerde = require("./fieldSerde.cjs");
+const require_EntityMetadata = require("./EntityMetadata.cjs");
+const require_temporal = require("./temporal.cjs");
+const require_fields = require("./fields.cjs");
+const require_changes = require("./changes.cjs");
+const require_reactiveHints = require("./reactiveHints.cjs");
+const require_normalizeHints = require("./normalizeHints.cjs");
+const require_loadHints = require("./loadHints.cjs");
+const require_utils = require("./utils.cjs");
+const require_drivers_buildUtils = require("./drivers/buildUtils.cjs");
+const require_loadLens = require("./loadLens.cjs");
+const require_logging_FactoryLogger = require("./logging/FactoryLogger.cjs");
+const require_newTestInstance = require("./newTestInstance.cjs");
+const require_preloading_partitionHint = require("./preloading/partitionHint.cjs");
+const require_skipCondition = require("./skipCondition.cjs");
+const require_Expr = require("./Expr.cjs");
+const require_Tables = require("./Tables.cjs");
+const require_ConditionBuilder = require("./ConditionBuilder.cjs");
+const require_InstanceData = require("./InstanceData.cjs");
+const require_PluginManager = require("./PluginManager.cjs");
+const require_QueryParser_collectionJoins = require("./QueryParser.collectionJoins.cjs");
+const require_QueryVisitor = require("./QueryVisitor.cjs");
+const require_drivers_EntityWriter = require("./drivers/EntityWriter.cjs");
+const require_unnest = require("./unnest.cjs");
+const require_runtimeConfig = require("./runtimeConfig.cjs");
+const require_serde = require("./serde.cjs");
+const require_temporalMappers = require("./temporalMappers.cjs");
+const require_drivers_buildRawQuery = require("./drivers/buildRawQuery.cjs");
+const require_driverApi = require("./driverApi.cjs");
+const require_drivers_IdAssigner = require("./drivers/IdAssigner.cjs");
+require("./drivers/index.cjs");
+const require_json = require("./json.cjs");
+const require_logging_FieldLogger = require("./logging/FieldLogger.cjs");
+const require_plugins_ImmutableEntitiesPlugin = require("./plugins/ImmutableEntitiesPlugin.cjs");
+const require_preloading_JsonAggregatePreloader = require("./preloading/JsonAggregatePreloader.cjs");
+const require_query = require("./query.cjs");
+const require_rules = require("./rules.cjs");
+const require_nowUTC = require("./nowUTC.cjs");
+const require_upsert = require("./upsert.cjs");
+const require_withLoaded = require("./withLoaded.cjs");
+const require_EntityManager = require("./EntityManager.cjs");
+const require_Entity = require("./Entity.cjs");
+const require_BaseEntity = require("./BaseEntity.cjs");
+const require_defaults = require("./defaults.cjs");
+const require_config = require("./config.cjs");
+const require_configure = require("./configure.cjs");
+const require_Aliases = require("./Aliases.cjs");
+const require_QueryParser = require("./QueryParser.cjs");
+const require_AliasAssigner = require("./AliasAssigner.cjs");
+let joist_utils = require("joist-utils");
+//#region src/index.ts
+const testing = {
+	isAllSqlPaths: require_loadLens.isAllSqlPaths,
+	getDefaultDependencies: require_defaults.getDefaultDependencies,
+	partitionHint: require_preloading_partitionHint.partitionHint
+};
+const internals = { buildWhereClause: require_drivers_buildUtils.buildWhereClause };
+/**
+* Sets each value in `values` on the current entity.
+*
+* The default behavior is that passing a value as either `null` or `undefined` will set
+* the field as `undefined`, i.e. automatic `null` to `undefined` conversion.
+*
+* However, if you pass `ignoreUndefined: true`, then any opt that is `undefined` will be treated
+* as "do not set", and `null` will still mean "set to `undefined`". This is useful for implementing
+* APIs were an input of `undefined` means "do not set / noop" and `null` means "unset".
+*
+* Note that constructors _always_ call this method, but if the call is coming from `em.hydrate`, we
+* use `values` being a primary key to short-circuit and let hydration callers assign the values
+* returned by the serde `fromRow` methods.
+*/
+function setOpts(entity, values, opts) {
+	const { calledFromConstructor = false, partial } = opts || {};
+	if (values !== void 0) {
+		const meta = require_EntityMetadata.getMetadata(entity);
+		for (const [key, _value] of Object.entries(values)) setOpt(meta, entity, key, _value, partial, calledFromConstructor);
+	}
+}
+/**
+* Applies some standard behavior & protections to `entity[key] = value`. I.e.
+*
+* - We don't set over AsyncProperties/relations/etc., and instead call current.set(value)
+* - We catch missing/invalid field names
+* - We handle FactoryInitialValues
+*/
+function setOpt(meta, entity, key, _value, partial = false, calledFromConstructor = false) {
+	if (!meta.allFields[key]) {
+		if (!require_getProperties.getProperties(meta)[key]) throw new Error(`Unknown field ${key}`);
+	}
+	if (partial && _value === void 0) return;
+	if (meta.inheritanceType === "sti" && require_EntityMetadata.getBaseMeta(meta).stiDiscriminatorField === key) return;
+	const value = _value === null ? void 0 : _value;
+	const current = key === "id" ? require_fields.getField(entity, key) : entity[key];
+	if (current instanceof require_relations_AbstractRelationImpl.AbstractRelationImpl) {
+		if (calledFromConstructor) current.setFromOpts(value);
+		else current.set(value);
+	} else if (require_relations_LazyField.isLazyField(current)) current.set(value);
+	else if (require_relations_hasProperty.isProperty(current) || require_relations_AsyncProperty.isAsyncProperty(current) || require_relations_ReactiveGetter.isReactiveGetter(current)) throw new Error(`Invalid argument, cannot set over ${key} ${current.constructor.name}`);
+	else if (require_relations_ReactiveField.isReactiveField(current) || require_relations_AsyncReactiveField.isAsyncReactiveField(current)) {
+		if (value instanceof require_newTestInstance.FactoryInitialValue) {
+			if (current instanceof require_relations_ReactiveField.ReactiveFieldImpl) current.setFactoryValue(value.value);
+			else if (current instanceof require_relations_AsyncReactiveField.AsyncReactiveFieldImpl) current.setFactoryValue(value.value);
+			else throw new Error(`Unhandled case ${current.constructor.name}`);
+		} else throw new Error(`Invalid argument, cannot set over ${key} ${current.constructor.name}`);
+	} else if (key === "id" && entity.isNewEntity) require_fields.setField(entity, key, value);
+	else entity[key] = value;
+}
+function ensureNotDeleted(entity, ignore) {
+	if (entity.isDeletedEntity && (ignore === void 0 || require_BaseEntity.getInstanceData(entity).isDeletedAndFlushed)) require_utils.fail(`${entity} is marked as deleted`);
+}
+function getRequiredKeys(entityOrType) {
+	return Object.values(require_EntityMetadata.getMetadata(entityOrType).fields).filter((f) => f.required).map((f) => f.fieldName);
+}
+function getRelations(entity) {
+	return Object.entries(require_getProperties.getProperties(require_EntityMetadata.getMetadata(entity))).filter(([, v]) => v instanceof require_relations_AbstractRelationImpl.AbstractRelationImpl).map(([name]) => entity[name]);
+}
+function getRelationEntries(entity) {
+	return Object.entries(require_getProperties.getProperties(require_EntityMetadata.getMetadata(entity))).filter(([, v]) => v instanceof require_relations_AbstractRelationImpl.AbstractRelationImpl).map(([name]) => [name, entity[name]]);
+}
+/** Casts a "maybe abstract" cstr to a concrete cstr when the calling code knows it's safe. */
+function asConcreteCstr(cstr) {
+	return cstr;
+}
+/**
+* Thrown when `.id` is accessed on an entity that does not have an id yet.
+*
+* For Postgres, entities are actually allowed to have ids pre-INSERT, if you call
+* `em.assignNewIds()`. Other databases typically require INSERTs to trigger the auto
+* id assignment.
+*/
+var NoIdError = class extends Error {};
+/** Throws a `NoIdError` for `entity`, i.e. because `id` was called before being saved. */
+function failNoIdYet(entity) {
+	throw new NoIdError(`${entity} has no id yet`);
+}
+/**
+* Add a static function since getters can't have type guards.
+*
+* See https://github.com/microsoft/TypeScript/issues/43368
+*/
+function isNewEntity(entity) {
+	return entity.isNewEntity;
+}
+//#endregion
+exports.AliasAssigner = require_AliasAssigner.AliasAssigner;
+exports.AsyncPropertyImpl = require_relations_AsyncProperty.AsyncPropertyImpl;
+exports.BaseEntity = require_BaseEntity.BaseEntity;
+exports.BigIntSerde = require_serde.BigIntSerde;
+exports.Column = require_columns.Column;
+exports.ConditionBuilder = require_ConditionBuilder.ConditionBuilder;
+exports.ConfigApi = require_config.ConfigApi;
+exports.CustomCollection = require_relations_CustomCollection.CustomCollection;
+exports.CustomReference = require_relations_CustomReference.CustomReference;
+exports.CustomSerdeAdapter = require_serde.CustomSerdeAdapter;
+exports.DateSerde = require_serde.DateSerde;
+exports.DecimalToNumberSerde = require_serde.DecimalToNumberSerde;
+exports.EntityManager = require_EntityManager.EntityManager;
+exports.EnumArrayFieldSerde = require_serde.EnumArrayFieldSerde;
+exports.EnumCollectionImpl = require_relations_EnumCollection.EnumCollectionImpl;
+exports.EnumFieldSerde = require_serde.EnumFieldSerde;
+exports.FieldColumn = require_fieldSerde.FieldColumn;
+exports.FieldLogger = require_logging_FieldLogger.FieldLogger;
+exports.ImmutableEntitiesPlugin = require_plugins_ImmutableEntitiesPlugin.ImmutableEntitiesPlugin;
+exports.InstanceData = require_InstanceData.InstanceData;
+exports.JoinRowOperation = require_JoinRows.JoinRowOperation;
+exports.JsonAggregatePreloader = require_preloading_JsonAggregatePreloader.JsonAggregatePreloader;
+exports.JsonSerde = require_serde.JsonSerde;
+exports.KeySerde = require_serde.KeySerde;
+exports.LazyFieldImpl = require_relations_LazyField.LazyFieldImpl;
+exports.ManyToManyCollection = require_relations_ManyToManyCollection.ManyToManyCollection;
+exports.ManyToManyLargeCollection = require_relations_ManyToManyLargeCollection.ManyToManyLargeCollection;
+exports.ManyToOneReferenceImpl = require_relations_ManyToOneReference.ManyToOneReferenceImpl;
+exports.NoIdError = NoIdError;
+exports.NotFoundError = require_EntityManager.NotFoundError;
+exports.OneToManyCollection = require_relations_OneToManyCollection.OneToManyCollection;
+exports.OneToManyLargeCollection = require_relations_OneToManyLargeCollection.OneToManyLargeCollection;
+exports.OneToOneReferenceImpl = require_relations_OneToOneReference.OneToOneReferenceImpl;
+exports.PlainDateSerde = require_serde.PlainDateSerde;
+exports.PlainDateTimeSerde = require_serde.PlainDateTimeSerde;
+exports.PlainTimeSerde = require_serde.PlainTimeSerde;
+exports.Plugin = require_PluginManager.Plugin;
+exports.PojoRowData = require_RowData.PojoRowData;
+exports.PolyComponent = require_fieldSerde.PolyComponent;
+exports.PolymorphicKeySerde = require_fieldSerde.PolymorphicKeySerde;
+exports.PolymorphicReferenceImpl = require_relations_PolymorphicReference.PolymorphicReferenceImpl;
+exports.PrimitiveSerde = require_serde.PrimitiveSerde;
+exports.PropertyImpl = require_relations_hasProperty.PropertyImpl;
+exports.RandomUuidAssigner = require_drivers_IdAssigner.RandomUuidAssigner;
+exports.ReactionLogger = require_logging_ReactionLogger.ReactionLogger;
+exports.ReactiveManyToManyImpl = require_relations_ReactiveManyToMany.ReactiveManyToManyImpl;
+exports.ReactiveManyToManyOtherSideImpl = require_relations_ReactiveManyToManyOtherSide.ReactiveManyToManyOtherSideImpl;
+exports.ReactiveReferenceImpl = require_relations_ReactiveReference.ReactiveReferenceImpl;
+exports.ReadOnlyError = require_EntityManager.ReadOnlyError;
+exports.RecursiveCycleError = require_relations_RecursiveCycleError.RecursiveCycleError;
+exports.SequenceIdAssigner = require_drivers_IdAssigner.SequenceIdAssigner;
+exports.SimpleFieldSerde = require_fieldSerde.SimpleFieldSerde;
+exports.StubbedRelation = require_withLoaded.StubbedRelation;
+exports.SuperstructSerde = require_serde.SuperstructSerde;
+exports.Temporal = require_temporal.Temporal;
+exports.TestUuidAssigner = require_drivers_IdAssigner.TestUuidAssigner;
+exports.Todo = require_Todo.Todo;
+exports.TooManyError = require_EntityManager.TooManyError;
+exports.UnknownProperty = require_getProperties.UnknownProperty;
+exports.ValidationCode = require_rules.ValidationCode;
+exports.ValidationErrors = require_rules.ValidationErrors;
+exports.ZodSerde = require_serde.ZodSerde;
+exports.ZonedDateTimeSerde = require_serde.ZonedDateTimeSerde;
+exports.abbreviation = require_utils.abbreviation;
+exports.addTablePerClassJoinsAndClassTag = require_QueryParser.addTablePerClassJoinsAndClassTag;
+exports.alias = require_Aliases.alias;
+exports.aliases = require_Aliases.aliases;
+exports.appendStack = require_EntityManager.appendStack;
+exports.asConcreteCstr = asConcreteCstr;
+exports.asNew = require_utils.asNew;
+exports.assertIdIsTagged = require_keys.assertIdIsTagged;
+exports.assertIdsAreTagged = require_keys.assertIdsAreTagged;
+exports.assertLoaded = require_loadHints.assertLoaded;
+exports.assertNever = require_utils.assertNever;
+exports.buildCteSql = require_drivers_buildRawQuery.buildCteSql;
+exports.buildRawQuery = require_drivers_buildRawQuery.buildRawQuery;
+exports.buildUnnestCte = require_unnest.buildUnnestCte;
+exports.buildValueCondition = require_drivers_buildUtils.buildValueCondition;
+exports.buildWhereClause = require_drivers_buildUtils.buildWhereClause;
+exports.cannotBeChanged = require_rules.cannotBeChanged;
+exports.cannotBeUpdated = require_rules.cannotBeUpdated;
+exports.cleanSql = require_utils.cleanSql;
+exports.cleanStringValue = require_utils.cleanStringValue;
+exports.configureMetadata = require_configure.configureMetadata;
+exports.convertToLoadHint = require_reactiveHints.convertToLoadHint;
+exports.createRowFromEntityData = require_EntityManager.createRowFromEntityData;
+exports.deTagId = require_keys.deTagId;
+exports.deTagIds = require_keys.deTagIds;
+exports.deepNormalizeHint = require_normalizeHints.deepNormalizeHint;
+exports.defaultValue = require_newTestInstance.defaultValue;
+exports.driverAfterBegin = require_EntityManager.driverAfterBegin;
+exports.driverAfterCommit = require_EntityManager.driverAfterCommit;
+exports.driverApi = require_driverApi.driverApi;
+exports.driverBeforeBegin = require_EntityManager.driverBeforeBegin;
+exports.driverBeforeCommit = require_EntityManager.driverBeforeCommit;
+exports.emptyRowData = require_RowData.emptyRowData;
+exports.ensureLoaded = require_loadHints.ensureLoaded;
+exports.ensureNotDeleted = ensureNotDeleted;
+exports.ensureRectangularArraySizes = require_unnest.ensureRectangularArraySizes;
+exports.ensureTagged = require_keys.ensureTagged;
+exports.ensureWithLoaded = require_withLoaded.ensureWithLoaded;
+exports.entityQueryBrand = require_query.entityQueryBrand;
+exports.exprBrand = require_Expr.exprBrand;
+exports.factories = require_newTestInstance.factories;
+exports.fail = require_utils.fail;
+exports.failIfAnyRejected = require_utils.failIfAnyRejected;
+exports.failNoIdYet = failNoIdYet;
+exports.filterSoftDeletes = require_QueryParser.filterSoftDeletes;
+exports.findFilterField = require_QueryParser.findFilterField;
+exports.generateOps = require_drivers_EntityWriter.generateOps;
+exports.getAliasMetadata = require_Aliases.getAliasMetadata;
+exports.getAliasMgmt = require_Aliases.getAliasMgmt;
+exports.getBaseAndSelfMetas = require_EntityMetadata.getBaseAndSelfMetas;
+exports.getBaseMeta = require_EntityMetadata.getBaseMeta;
+exports.getBaseSelfAndSubMetas = require_EntityMetadata.getBaseSelfAndSubMetas;
+exports.getConstructorFromTaggedId = require_configure.getConstructorFromTaggedId;
+exports.getDefaultEntityLimit = require_EntityManager.getDefaultEntityLimit;
+exports.getEmInternalApi = require_EntityManager.getEmInternalApi;
+exports.getField = require_fields.getField;
+exports.getInstanceData = require_BaseEntity.getInstanceData;
+exports.getLazyFields = require_getProperties.getLazyFields;
+exports.getLens = require_loadLens.getLens;
+exports.getLensPath = require_loadLens.getLensPath;
+exports.getMaybeCtiAlias = require_Aliases.getMaybeCtiAlias;
+exports.getMetadata = require_EntityMetadata.getMetadata;
+exports.getMetadataForField = require_EntityMetadata.getMetadataForField;
+exports.getMetadataForTable = require_configure.getMetadataForTable;
+exports.getMetadataForType = require_configure.getMetadataForType;
+exports.getProperties = require_getProperties.getProperties;
+exports.getRelationEntries = getRelationEntries;
+exports.getRelations = getRelations;
+exports.getRequiredKeys = getRequiredKeys;
+exports.getRuntimeConfig = require_runtimeConfig.getRuntimeConfig;
+exports.getSubMetas = require_EntityMetadata.getSubMetas;
+exports.getTableMetadata = require_Tables.getTableMetadata;
+exports.getTableMgmt = require_Tables.getTableMgmt;
+exports.getTables = require_QueryParser.getTables;
+exports.getTestIndex = require_newTestInstance.getTestIndex;
+exports.hasAsyncMethod = require_relations_hasAsyncMethod.hasAsyncMethod;
+exports.hasAsyncProperty = require_relations_AsyncProperty.hasAsyncProperty;
+exports.hasAsyncReactiveField = require_relations_AsyncReactiveField.hasAsyncReactiveField;
+exports.hasCustomCollection = require_relations_CustomCollection.hasCustomCollection;
+exports.hasCustomReference = require_relations_CustomReference.hasCustomReference;
+exports.hasEnumCollection = require_relations_EnumCollection.hasEnumCollection;
+exports.hasLargeMany = require_relations_OneToManyLargeCollection.hasLargeMany;
+exports.hasLargeManyToMany = require_relations_ManyToManyLargeCollection.hasLargeManyToMany;
+exports.hasLazyField = require_relations_LazyField.hasLazyField;
+exports.hasMany = require_relations_OneToManyCollection.hasMany;
+exports.hasManyDerived = require_relations_hasManyDerived.hasManyDerived;
+exports.hasManyThrough = require_relations_hasManyThrough.hasManyThrough;
+exports.hasManyToMany = require_relations_ManyToManyCollection.hasManyToMany;
+exports.hasOne = require_relations_ManyToOneReference.hasOne;
+exports.hasOneDerived = require_relations_hasOneDerived.hasOneDerived;
+exports.hasOnePolymorphic = require_relations_PolymorphicReference.hasOnePolymorphic;
+exports.hasOneThrough = require_relations_hasOneThrough.hasOneThrough;
+exports.hasOneToOne = require_relations_OneToOneReference.hasOneToOne;
+exports.hasProperty = require_relations_hasProperty.hasProperty;
+exports.hasReactiveField = require_relations_ReactiveField.hasReactiveField;
+exports.hasReactiveGetter = require_relations_ReactiveGetter.hasReactiveGetter;
+exports.hasReactiveManyToMany = require_relations_ReactiveManyToMany.hasReactiveManyToMany;
+exports.hasReactiveManyToManyOtherSide = require_relations_ReactiveManyToManyOtherSide.hasReactiveManyToManyOtherSide;
+exports.hasReactiveProperty = require_relations_hasProperty.hasReactiveProperty;
+exports.hasReactiveReference = require_relations_ReactiveReference.hasReactiveReference;
+exports.hasRecursiveChildren = require_relations_RecursiveCollection.hasRecursiveChildren;
+exports.hasRecursiveM2m = require_relations_RecursiveCollection.hasRecursiveM2m;
+exports.hasRecursiveParents = require_relations_RecursiveCollection.hasRecursiveParents;
+exports.hasSerde = require_fieldSerde.hasSerde;
+exports.indexBy = require_utils.indexBy;
+exports.internals = internals;
+exports.isAlias = require_Aliases.isAlias;
+exports.isAllSqlPaths = require_loadLens.isAllSqlPaths;
+exports.isAsyncProperty = require_relations_AsyncProperty.isAsyncProperty;
+exports.isAsyncReactiveField = require_relations_AsyncReactiveField.isAsyncReactiveField;
+exports.isChangeableField = require_fields.isChangeableField;
+exports.isCollection = require_relations_Collection.isCollection;
+exports.isCollectionField = require_EntityMetadata.isCollectionField;
+exports.isDefined = require_EntityManager.isDefined;
+exports.isEntity = require_Entity.isEntity;
+exports.isFactoryCreation = require_newTestInstance.isFactoryCreation;
+exports.isFieldSet = require_fields.isFieldSet;
+exports.isId = require_EntityManager.isId;
+exports.isInTrustedContext = require_trusted.isInTrustedContext;
+exports.isKey = require_EntityManager.isKey;
+exports.isLazyField = require_relations_LazyField.isLazyField;
+exports.isLensLoaded = require_loadLens.isLensLoaded;
+exports.isLensLoadedPath = require_loadLens.isLensLoadedPath;
+exports.isLoaded = require_loadHints.isLoaded;
+exports.isLoadedAsyncProperty = require_relations_AsyncProperty.isLoadedAsyncProperty;
+exports.isLoadedCollection = require_relations_Collection.isLoadedCollection;
+exports.isLoadedLazyField = require_relations_LazyField.isLoadedLazyField;
+exports.isLoadedOneToOneReference = require_relations_OneToOneReference.isLoadedOneToOneReference;
+exports.isLoadedProperty = require_relations_hasProperty.isLoadedProperty;
+exports.isLoadedReadOnlyCollection = require_relations_ReadOnlyCollection.isLoadedReadOnlyCollection;
+exports.isLoadedReference = require_relations_Reference.isLoadedReference;
+exports.isManyToManyEnumField = require_EntityMetadata.isManyToManyEnumField;
+exports.isManyToManyField = require_EntityMetadata.isManyToManyField;
+exports.isManyToOneField = require_EntityMetadata.isManyToOneField;
+exports.isManyToOneReference = require_relations_ManyToOneReference.isManyToOneReference;
+exports.isNew = require_loadHints.isNew;
+exports.isNewEntity = isNewEntity;
+exports.isOneToManyField = require_EntityMetadata.isOneToManyField;
+exports.isOneToOneField = require_EntityMetadata.isOneToOneField;
+exports.isOneToOneReference = require_relations_OneToOneReference.isOneToOneReference;
+exports.isPolymorphicField = require_EntityMetadata.isPolymorphicField;
+exports.isPolymorphicReference = require_relations_PolymorphicReference.isPolymorphicReference;
+exports.isProperty = require_relations_hasProperty.isProperty;
+exports.isReactiveField = require_relations_ReactiveField.isReactiveField;
+exports.isReactiveGetter = require_relations_ReactiveGetter.isReactiveGetter;
+exports.isReactiveManyToMany = require_relations_ReactiveManyToMany.isReactiveManyToMany;
+exports.isReactiveManyToManyOtherSide = require_relations_ReactiveManyToManyOtherSide.isReactiveManyToManyOtherSide;
+exports.isReactiveReference = require_relations_ReactiveReference.isReactiveReference;
+exports.isReadOnlyCollection = require_relations_ReadOnlyCollection.isReadOnlyCollection;
+exports.isReference = require_relations_Reference.isReference;
+exports.isReferenceField = require_EntityMetadata.isReferenceField;
+exports.isRelation = require_relations_Relation.isRelation;
+exports.isScope = require_scopes.isScope;
+exports.isScopeJoinFilter = require_scopes.isScopeJoinFilter;
+exports.isSelectAllFilter = require_scopes.isSelectAllFilter;
+exports.isTable = require_Tables.isTable;
+exports.isTaggedId = require_keys.isTaggedId;
+exports.isTypeOrSubType = require_reactiveHints.isTypeOrSubType;
+exports.keyToNumber = require_keys.keyToNumber;
+exports.keyToTaggedId = require_keys.keyToTaggedId;
+exports.kq = require_keywords.kq;
+exports.kqDot = require_keywords.kqDot;
+exports.kqStar = require_keywords.kqStar;
+exports.lazyExcludedSelects = require_QueryParser.lazyExcludedSelects;
+exports.lazyField = require_newEntity.lazyField;
+exports.lensPathToLoadHint = require_loadLens.lensPathToLoadHint;
+exports.lensToLoadHint = require_loadLens.lensToLoadHint;
+exports.lensToPath = require_loadLens.lensToPath;
+exports.loadLens = require_loadLens.loadLens;
+exports.loadLensPath = require_loadLens.loadLensPath;
+exports.makeLike = require_QueryParser.makeLike;
+exports.mapPathsToTarget = require_loadLens.mapPathsToTarget;
+exports.mapToDb = require_QueryParser.mapToDb;
+exports.maxValueRule = require_rules.maxValueRule;
+exports.maybeAddIdNotNulls = require_QueryParser.maybeAddIdNotNulls;
+exports.maybeAddNotSoftDeleted = require_QueryParser.maybeAddNotSoftDeleted;
+exports.maybeAddOrderBy = require_QueryParser.maybeAddOrderBy;
+exports.maybeBranchValue = require_newTestInstance.maybeBranchValue;
+exports.maybeGetConstructorFromReference = require_configure.maybeGetConstructorFromReference;
+exports.maybeNew = require_newTestInstance.maybeNew;
+exports.maybeNewPoly = require_newTestInstance.maybeNewPoly;
+exports.maybePopulateThen = require_loadHints.maybePopulateThen;
+exports.maybeRequireTemporal = require_temporal.maybeRequireTemporal;
+exports.maybeResolveReferenceToId = require_keys.maybeResolveReferenceToId;
+exports.mergeFindOptions = require_EntityFilter.mergeFindOptions;
+exports.minValueRule = require_rules.minValueRule;
+exports.mustBeSubType = require_rules.mustBeSubType;
+exports.newAliasProxy = require_Aliases.newAliasProxy;
+exports.newChangesProxy = require_changes.newChangesProxy;
+Object.defineProperty(exports, "newPgConnectionConfig", {
+	enumerable: true,
+	get: function() {
+		return joist_utils.newPgConnectionConfig;
+	}
+});
+exports.newRequiredLazyFieldRule = require_rules.newRequiredLazyFieldRule;
+exports.newRequiredRule = require_rules.newRequiredRule;
+exports.newScopeFn = require_scopes.newScopeFn;
+exports.newTableProxy = require_Tables.newTableProxy;
+exports.newTestInstance = require_newTestInstance.newTestInstance;
+exports.noValue = require_newTestInstance.noValue;
+exports.noopFieldLogger = require_logging_FieldLogger.noopFieldLogger;
+exports.normalizeHint = require_normalizeHints.normalizeHint;
+exports.nowUTC = require_nowUTC.nowUTC;
+exports.opToFn = require_EntityGraphQLFilter.opToFn;
+exports.operators = require_EntityGraphQLFilter.operators;
+exports.optimizeCollectionJoins = require_QueryParser_collectionJoins.optimizeCollectionJoins;
+exports.parseAlias = require_QueryParser.parseAlias;
+exports.parseEntityFilter = require_QueryParser.parseEntityFilter;
+exports.parseFindQuery = require_QueryParser.parseFindQuery;
+exports.parseValueFilter = require_QueryParser.parseValueFilter;
+exports.partition = require_utils.partition;
+exports.plainDateMapper = require_temporalMappers.plainDateMapper;
+exports.plainDateTimeMapper = require_temporalMappers.plainDateTimeMapper;
+exports.plainTimeMapper = require_temporalMappers.plainTimeMapper;
+exports.polymorphicField = require_fieldSerde.polymorphicField;
+exports.query = require_query.query;
+exports.rangeValueRule = require_rules.rangeValueRule;
+exports.requireTemporal = require_temporal.requireTemporal;
+exports.resetBootFlag = require_config.resetBootFlag;
+exports.resetDefaultEntityLimit = require_EntityManager.resetDefaultEntityLimit;
+exports.resolveScope = require_scopes.resolveScope;
+exports.reverseReactiveHint = require_reactiveHints.reverseReactiveHint;
+exports.runInTrustedContext = require_trusted.runInTrustedContext;
+exports.sameEntity = require_EntityManager.sameEntity;
+exports.sameReference = require_EntityManager.sameReference;
+exports.setDefaultEntityLimit = require_EntityManager.setDefaultEntityLimit;
+exports.setFactoryLogging = require_newTestInstance.setFactoryLogging;
+exports.setFactoryWriter = require_logging_FactoryLogger.setFactoryWriter;
+exports.setField = require_fields.setField;
+exports.setLastNow = require_EntityManager.setLastNow;
+exports.setOpt = setOpt;
+exports.setOpts = setOpts;
+exports.setReactionLogging = require_logging_ReactionLogger.setReactionLogging;
+exports.setRuntimeConfig = require_runtimeConfig.setRuntimeConfig;
+exports.setTaggedIdDelimiter = require_keys.setTaggedIdDelimiter;
+exports.skipCondition = require_skipCondition.skipCondition;
+exports.sql = require_query.sql;
+exports.stiSubtypeFilter = require_QueryParser.stiSubtypeFilter;
+exports.subqueryBrand = require_query.subqueryBrand;
+exports.table = require_Tables.table;
+exports.tableMgmt = require_Tables.tableMgmt;
+exports.tables = require_Tables.tables;
+exports.tagFromId = require_keys.tagFromId;
+exports.tagId = require_keys.tagId;
+exports.tagIds = require_keys.tagIds;
+exports.testIndex = require_newTestInstance.testIndex;
+exports.testing = testing;
+exports.toIdOf = require_keys.toIdOf;
+exports.toJSON = require_json.toJSON;
+exports.toTaggedId = require_keys.toTaggedId;
+exports.unsafeDeTagIds = require_keys.unsafeDeTagIds;
+exports.unsafeLoaded = require_loadHints.unsafeLoaded;
+exports.updatePartial = require_upsert.updatePartial;
+exports.upsert = require_upsert.upsert;
+exports.visitConditions = require_QueryVisitor.visitConditions;
+exports.withLoaded = require_withLoaded.withLoaded;
+exports.zeroTo = require_utils.zeroTo;
+exports.zonedDateTimeMapper = require_temporalMappers.zonedDateTimeMapper;
+
+//# sourceMappingURL=index.cjs.map

package/build/index.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.cjs","names":["getMetadata","getProperties","getBaseMeta","getField","AbstractRelationImpl","isLazyField","isProperty","isAsyncProperty","isReactiveGetter","isReactiveField","isAsyncReactiveField","FactoryInitialValue","ReactiveFieldImpl","AsyncReactiveFieldImpl","getInstanceData"],"sources":["../src/index.ts"],"sourcesContent":["import { getInstanceData } from \"./BaseEntity.ts\";\nimport { getDefaultDependencies } from \"./defaults.ts\";\nimport { buildWhereClause } from \"./drivers/buildUtils.ts\";\nimport { type Entity } from \"./Entity.ts\";\nimport { type EntityConstructor, type MaybeAbstractEntityConstructor } from \"./EntityManager.ts\";\nimport { type EntityMetadata, getBaseMeta, getMetadata } from \"./EntityMetadata.ts\";\nimport { getField, setField } from \"./fields.ts\";\nimport { getProperties } from \"./getProperties.ts\";\nimport { type New } from \"./loadHints.ts\";\nimport { isAllSqlPaths } from \"./loadLens.ts\";\nimport { FactoryInitialValue } from \"./newTestInstance.ts\";\nimport { partitionHint } from \"./preloading/partitionHint.ts\";\nimport { AbstractRelationImpl } from \"./relations/AbstractRelationImpl.ts\";\nimport { AsyncReactiveFieldImpl } from \"./relations/AsyncReactiveField.ts\";\nimport {\n  isAsyncProperty,\n  isAsyncReactiveField,\n  isLazyField,\n  isProperty,\n  isReactiveField,\n  isReactiveGetter,\n} from \"./relations/index.ts\";\nimport { ReactiveFieldImpl } from \"./relations/ReactiveField.ts\";\nimport { type OptsOf } from \"./typeMap.ts\";\nimport { fail } from \"./utils.ts\";\n\nexport const testing = { isAllSqlPaths, getDefaultDependencies, partitionHint };\nexport const internals = { buildWhereClause };\nexport { newPgConnectionConfig } from \"joist-utils\";\nexport { AliasAssigner } from \"./AliasAssigner.ts\";\n// Domain aliases belong to em.find; physical table expressions belong to em.query/em.execute.\nexport {\n  alias,\n  aliases,\n  getAliasMetadata,\n  getAliasMgmt,\n  getMaybeCtiAlias,\n  isAlias,\n  newAliasProxy,\n  type Alias,\n  type AliasBrand,\n  type AliasMgmt,\n  type AliasColumn,\n  type EntityAlias,\n  type PolyAlias,\n  type PrimitiveAlias,\n} from \"./Aliases.ts\";\nexport {\n  table,\n  tables,\n  tableMgmt,\n  getTableMetadata,\n  getTableMgmt,\n  isTable,\n  newTableProxy,\n  type Table,\n  type TableBrand,\n  type TableFor,\n  type TableMgmt,\n  type ReferenceJoin,\n  type PrimitiveColumn,\n  type EntityColumn,\n  type ReferenceColumn,\n  type CollectionJoin,\n  type PolyReference,\n} from \"./Tables.ts\";\nexport { BaseEntity, getInstanceData } from \"./BaseEntity.ts\";\nexport { ConditionBuilder } from \"./ConditionBuilder.ts\";\nexport { type Entity, type IdType, isEntity } from \"./Entity.ts\";\nexport type * from \"./EntityFields.ts\";\nexport * from \"./EntityFilter.ts\";\nexport * from \"./EntityGraphQLFilter.ts\";\nexport * from \"./EntityManager.ts\";\nexport * from \"./EntityMetadata.ts\";\nexport type {\n  DeleteStatement,\n  ExecuteResult,\n  InsertStatement,\n  InsertValues,\n  MutationReturning,\n  MutationStatement,\n  UpdateStatement,\n  UpdateValues,\n} from \"./execute.ts\";\nexport type { EnumMetadata } from \"./EnumMetadata.ts\";\n// `em.query`'s expression surface. Only the user-facing types are re-exported: the runtime half\n// (BaseExpr, asNode, deferredCondition, the FnExpr/TemplateExpr node classes) stays internal to\n// joist-core, so `toSql`/`decode`/`encode` never show up as something a user could call.\nexport { type Expr, type ExprBrand, exprBrand, type ExprLike, type InnerJoin, type LeftJoin } from \"./Expr.ts\";\nexport { skipCondition } from \"./skipCondition.ts\";\nexport type { EntityOrId, HintNode } from \"./HintTree.ts\";\nexport { InstanceData } from \"./InstanceData.ts\";\nexport { type JoinColumnValue, type JoinRow, JoinRowOperation, type ManyToManyLike } from \"./JoinRows.ts\";\nexport type * from \"./PendingChanges.ts\";\nexport { Plugin } from \"./PluginManager.ts\";\nexport * from \"./QueryParser.ts\";\nexport * from \"./QueryParser.collectionJoins.ts\";\nexport { visitConditions } from \"./QueryVisitor.ts\";\nexport * from \"./RowData.ts\";\nexport { type JoinRowTodo, Todo } from \"./Todo.ts\";\nexport * from \"./changes.ts\";\nexport { ConfigApi, type EntityHook, resetBootFlag } from \"./config.ts\";\nexport {\n  configureMetadata,\n  getConstructorFromTaggedId,\n  getMetadataForTable,\n  getMetadataForType,\n  maybeGetConstructorFromReference,\n} from \"./configure.ts\";\nexport { driverApi } from \"./driverApi.ts\";\nexport * from \"./drivers/index.ts\";\nexport { getField, isChangeableField, isFieldSet, setField } from \"./fields.ts\";\nexport * from \"./getProperties.ts\";\nexport * from \"./json.ts\";\nexport * from \"./keys.ts\";\nexport { kq, kqDot, kqStar } from \"./keywords.ts\";\nexport {\n  assertLoaded,\n  type DeepNew,\n  ensureLoaded,\n  isLoaded,\n  isNew,\n  type Loadable,\n  type Loaded,\n  type LoadHint,\n  type MarkLoaded,\n  maybePopulateThen,\n  type NestedLoadHint,\n  type New,\n  type RelationsIn,\n  unsafeLoaded,\n} from \"./loadHints.ts\";\nexport * from \"./loadLens.ts\";\nexport { setFactoryWriter } from \"./logging/FactoryLogger.ts\";\nexport * from \"./logging/FieldLogger.ts\";\nexport { ReactionLogger, setReactionLogging } from \"./logging/ReactionLogger.ts\";\nexport { lazyField } from \"./newEntity.ts\";\nexport {\n  defaultValue,\n  factories,\n  type FactoryEntityOpt,\n  type FactoryOpts,\n  getTestIndex,\n  isFactoryCreation,\n  maybeBranchValue,\n  maybeNew,\n  maybeNewPoly,\n  newTestInstance,\n  noValue,\n  setFactoryLogging,\n  testIndex,\n} from \"./newTestInstance.ts\";\nexport { deepNormalizeHint, normalizeHint } from \"./normalizeHints.ts\";\nexport { ImmutableEntitiesPlugin } from \"./plugins/ImmutableEntitiesPlugin.ts\";\nexport type { JoinResult, PreloadHydrator, PreloadPlugin } from \"./plugins/PreloadPlugin.ts\";\nexport { JsonAggregatePreloader } from \"./preloading/JsonAggregatePreloader.ts\";\n// `em.query`'s query surface; the parse pipeline (SubqueryHandle, parseUserQuery, Plan) stays internal\nexport {\n  type CheckScope,\n  type Clauses,\n  type EntityQuery,\n  entityQueryBrand,\n  type MaybeNull,\n  type NameOf,\n  type NotWidened,\n  type OrderByDirection,\n  type OrderByKeys,\n  type Query,\n  type QueryArg,\n  type QueryJoin,\n  type QueryJoins,\n  type QueryOrderBy,\n  type QueryRow,\n  type QuerySelect,\n  type QuerySource,\n  type QueryValue,\n  type SetQuery,\n  query,\n  sql,\n  type Subquery,\n  type SubqueryBrand,\n  subqueryBrand,\n} from \"./query.ts\";\nexport {\n  convertToLoadHint,\n  isTypeOrSubType,\n  type Reactable,\n  type Reacted,\n  type ReactiveHint,\n  type ReactiveTarget,\n  reverseReactiveHint,\n} from \"./reactiveHints.ts\";\nexport * from \"./relations/index.ts\";\nexport {\n  cannotBeChanged,\n  cannotBeUpdated,\n  type GenericError,\n  maxValueRule,\n  minValueRule,\n  mustBeSubType,\n  newRequiredLazyFieldRule,\n  newRequiredRule,\n  rangeValueRule,\n  ValidationCode,\n  type ValidationError,\n  ValidationErrors,\n  type ValidationRule,\n  type ValidationRuleInternal,\n  type ValidationRuleResult,\n} from \"./rules.ts\";\nexport { getRuntimeConfig, setRuntimeConfig, type RuntimeConfig } from \"./runtimeConfig.ts\";\nexport { nowUTC } from \"./nowUTC.ts\";\nexport * from \"./serde.ts\";\nexport * from \"./columns.ts\";\nexport * from \"./fieldSerde.ts\";\nexport * from \"./scopes.ts\";\nexport { maybeRequireTemporal, requireTemporal, Temporal } from \"./temporal.ts\";\nexport * from \"./temporalMappers.ts\";\nexport { isInTrustedContext, runInTrustedContext } from \"./trusted.ts\";\nexport type * from \"./typeMap.ts\";\nexport { buildUnnestCte, ensureRectangularArraySizes } from \"./unnest.ts\";\nexport { type DeepPartialOrNull, updatePartial, upsert } from \"./upsert.ts\";\nexport {\n  abbreviation,\n  asNew,\n  assertNever,\n  cleanSql,\n  cleanStringValue,\n  fail,\n  failIfAnyRejected,\n  indexBy,\n  partition,\n  zeroTo,\n} from \"./utils.ts\";\nexport { ensureWithLoaded, StubbedRelation, type WithLoaded, withLoaded } from \"./withLoaded.ts\";\n\n// https://spin.atomicobject.com/2018/01/15/typescript-flexible-nominal-typing/\ninterface Flavoring<FlavorT> {\n  _type?: FlavorT;\n}\n\nexport type Flavor<T, FlavorT> = T & Flavoring<FlavorT>;\n\n/**\n * Sets each value in `values` on the current entity.\n *\n * The default behavior is that passing a value as either `null` or `undefined` will set\n * the field as `undefined`, i.e. automatic `null` to `undefined` conversion.\n *\n * However, if you pass `ignoreUndefined: true`, then any opt that is `undefined` will be treated\n * as \"do not set\", and `null` will still mean \"set to `undefined`\". This is useful for implementing\n * APIs were an input of `undefined` means \"do not set / noop\" and `null` means \"unset\".\n *\n * Note that constructors _always_ call this method, but if the call is coming from `em.hydrate`, we\n * use `values` being a primary key to short-circuit and let hydration callers assign the values\n * returned by the serde `fromRow` methods.\n */\nexport function setOpts<T extends Entity>(\n  entity: T,\n  values: Partial<OptsOf<T>> | undefined,\n  opts?: { partial?: boolean; calledFromConstructor?: boolean },\n): void {\n  const { calledFromConstructor = false, partial } = opts || {};\n  // If `values` is undefined, we're being called by `createPartial` that will do its\n  // own opt handling, but we still want the sync defaults applied after this opts handling.\n  if (values !== undefined) {\n    const meta = getMetadata(entity);\n    for (const [key, _value] of Object.entries(values as {})) {\n      setOpt(meta, entity, key, _value, partial, calledFromConstructor);\n    }\n  }\n}\n\n/**\n * Applies some standard behavior & protections to `entity[key] = value`. I.e.\n *\n * - We don't set over AsyncProperties/relations/etc., and instead call current.set(value)\n * - We catch missing/invalid field names\n * - We handle FactoryInitialValues\n */\nexport function setOpt<T extends Entity>(\n  meta: EntityMetadata<T>,\n  entity: T,\n  key: string,\n  _value: any,\n  partial = false,\n  calledFromConstructor = false,\n): void {\n  const field = meta.allFields[key];\n  if (!field) {\n    // Allow setting non-field properties like fullName setters\n    const prop = getProperties(meta)[key];\n    if (!prop) {\n      throw new Error(`Unknown field ${key}`);\n    }\n  }\n\n  // If partial is set, we treat undefined as a noop\n  if (partial && _value === undefined) return;\n  // Ignore the STI discriminator, em.register will set this accordingly\n  if (meta.inheritanceType === \"sti\" && getBaseMeta(meta).stiDiscriminatorField === key) return;\n\n  // We let optional opts fields be `| null` for convenience, and convert to undefined.\n  const value = _value === null ? undefined : _value;\n\n  // Use `getField` to side-step `id` blowing up on new entities that are setting an\n  // explicit id; otherwise use `entity[key]` to get back the relation.\n  const current = key === \"id\" ? getField(entity, key) : (entity as any)[key];\n\n  if (current instanceof AbstractRelationImpl) {\n    if (calledFromConstructor) {\n      current.setFromOpts(value);\n    } else {\n      current.set(value);\n    }\n  } else if (isLazyField(current)) {\n    current.set(value);\n  } else if (isProperty(current) || isAsyncProperty(current) || isReactiveGetter(current)) {\n    throw new Error(`Invalid argument, cannot set over ${key} ${current.constructor.name}`);\n  } else if (isReactiveField(current) || isAsyncReactiveField(current)) {\n    if (value instanceof FactoryInitialValue) {\n      if (current instanceof ReactiveFieldImpl) {\n        current.setFactoryValue(value.value);\n      } else if (current instanceof AsyncReactiveFieldImpl) {\n        current.setFactoryValue(value.value);\n      } else {\n        throw new Error(`Unhandled case ${current.constructor.name}`);\n      }\n    } else {\n      throw new Error(`Invalid argument, cannot set over ${key} ${current.constructor.name}`);\n    }\n  } else {\n    // If setting an explicit id, go through setField, otherwise use\n    // `entity[key]` to set the value directly to that we go through setters.\n    if (key === \"id\" && entity.isNewEntity) {\n      setField(entity, key, value);\n    } else {\n      (entity as any)[key] = value;\n    }\n  }\n}\n\nexport function ensureNotDeleted(entity: Entity, ignore?: \"pending\"): void {\n  if (entity.isDeletedEntity && (ignore === undefined || getInstanceData(entity).isDeletedAndFlushed)) {\n    fail(`${entity} is marked as deleted`);\n  }\n}\n\n/** Adds `null` to every key in `T` to accept partial-update-style input. */\nexport type PartialOrNull<T> = {\n  [P in keyof T]?: T[P] | null;\n};\n\nexport function getRequiredKeys<T extends Entity>(entity: T): string[];\nexport function getRequiredKeys<T extends Entity>(type: EntityConstructor<T>): string[];\nexport function getRequiredKeys<T extends Entity>(entityOrType: T | EntityConstructor<T>): string[] {\n  return Object.values(getMetadata(entityOrType as any).fields)\n    .filter((f) => f.required)\n    .map((f) => f.fieldName);\n}\n\nexport function getRelations(entity: Entity): AbstractRelationImpl<any, any>[] {\n  return Object.entries(getProperties(getMetadata(entity)))\n    .filter(([, v]) => v instanceof AbstractRelationImpl)\n    .map(([name]) => (entity as any)[name]);\n}\n\nexport function getRelationEntries(entity: Entity): [string, AbstractRelationImpl<any, any>][] {\n  return Object.entries(getProperties(getMetadata(entity)))\n    .filter(([, v]) => v instanceof AbstractRelationImpl)\n    .map(([name]) => [name, (entity as any)[name]]);\n}\n\n/** Casts a \"maybe abstract\" cstr to a concrete cstr when the calling code knows it's safe. */\nexport function asConcreteCstr<T extends Entity>(cstr: MaybeAbstractEntityConstructor<T>): EntityConstructor<T> {\n  return cstr as any;\n}\n\n/**\n * Thrown when `.id` is accessed on an entity that does not have an id yet.\n *\n * For Postgres, entities are actually allowed to have ids pre-INSERT, if you call\n * `em.assignNewIds()`. Other databases typically require INSERTs to trigger the auto\n * id assignment.\n */\nexport class NoIdError extends Error {}\n\n/** Throws a `NoIdError` for `entity`, i.e. because `id` was called before being saved. */\nexport function failNoIdYet(entity: string): never {\n  throw new NoIdError(`${entity} has no id yet`);\n}\n\n/**\n * Add a static function since getters can't have type guards.\n *\n * See https://github.com/microsoft/TypeScript/issues/43368\n */\nexport function isNewEntity<T extends Entity>(entity: T): entity is New<T> {\n  return entity.isNewEntity;\n}\n"],"mappings":"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"}