Initial commit - Event Planner application
This commit is contained in:
mberlin
50
node_modules/@mikro-orm/core/hydration/Hydrator.d.ts
generated
vendored
Normal file
50
node_modules/@mikro-orm/core/hydration/Hydrator.d.ts
generated
vendored
Normal file
@@ -0,0 +1,50 @@
|
||||
import type { EntityData, EntityMetadata, EntityProperty, IHydrator } from '../typings.js';
|
||||
import type { EntityFactory } from '../entity/EntityFactory.js';
|
||||
import type { Platform } from '../platforms/Platform.js';
|
||||
import type { MetadataStorage } from '../metadata/MetadataStorage.js';
|
||||
import type { Configuration } from '../utils/Configuration.js';
|
||||
/** Abstract base class for hydrating entity instances from raw database data. */
|
||||
export declare abstract class Hydrator implements IHydrator {
|
||||
protected readonly metadata: MetadataStorage;
|
||||
protected readonly platform: Platform;
|
||||
protected readonly config: Configuration;
|
||||
protected running: boolean;
|
||||
constructor(metadata: MetadataStorage, platform: Platform, config: Configuration);
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrate<T extends object>(
|
||||
entity: T,
|
||||
meta: EntityMetadata<T>,
|
||||
data: EntityData<T>,
|
||||
factory: EntityFactory,
|
||||
type: 'full' | 'reference',
|
||||
newEntity?: boolean,
|
||||
convertCustomTypes?: boolean,
|
||||
schema?: string,
|
||||
parentSchema?: string,
|
||||
): void;
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrateReference<T extends object>(
|
||||
entity: T,
|
||||
meta: EntityMetadata<T>,
|
||||
data: EntityData<T>,
|
||||
factory: EntityFactory,
|
||||
convertCustomTypes?: boolean,
|
||||
schema?: string,
|
||||
parentSchema?: string,
|
||||
): void;
|
||||
/** Returns whether the hydrator is currently in the middle of hydrating an entity. */
|
||||
isRunning(): boolean;
|
||||
protected getProperties<T extends object>(meta: EntityMetadata<T>, type: 'full' | 'reference'): EntityProperty<T>[];
|
||||
protected hydrateProperty<T extends object>(
|
||||
entity: T,
|
||||
prop: EntityProperty<T>,
|
||||
data: EntityData<T>,
|
||||
factory: EntityFactory,
|
||||
newEntity?: boolean,
|
||||
convertCustomTypes?: boolean,
|
||||
): void;
|
||||
}
|
||||
49
node_modules/@mikro-orm/core/hydration/Hydrator.js
generated
vendored
Normal file
49
node_modules/@mikro-orm/core/hydration/Hydrator.js
generated
vendored
Normal file
@@ -0,0 +1,49 @@
|
||||
/** Abstract base class for hydrating entity instances from raw database data. */
|
||||
/* v8 ignore next */
|
||||
export class Hydrator {
|
||||
metadata;
|
||||
platform;
|
||||
config;
|
||||
running = false;
|
||||
constructor(metadata, platform, config) {
|
||||
this.metadata = metadata;
|
||||
this.platform = platform;
|
||||
this.config = config;
|
||||
}
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrate(entity, meta, data, factory, type, newEntity = false, convertCustomTypes = false, schema, parentSchema) {
|
||||
// the running state is used to consider propagation as hydration, saving the values directly to the entity data,
|
||||
// but we don't want that for new entities, their propagation should result in entity updates when flushing
|
||||
this.running = !newEntity;
|
||||
const props = this.getProperties(meta, type);
|
||||
for (const prop of props) {
|
||||
this.hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes);
|
||||
}
|
||||
this.running = false;
|
||||
}
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrateReference(entity, meta, data, factory, convertCustomTypes, schema, parentSchema) {
|
||||
this.running = true;
|
||||
meta.primaryKeys.forEach(pk => {
|
||||
this.hydrateProperty(entity, meta.properties[pk], data, factory, false, convertCustomTypes);
|
||||
});
|
||||
this.running = false;
|
||||
}
|
||||
/** Returns whether the hydrator is currently in the middle of hydrating an entity. */
|
||||
isRunning() {
|
||||
return this.running;
|
||||
}
|
||||
getProperties(meta, type) {
|
||||
if (type === 'reference') {
|
||||
return meta.primaryKeys.map(pk => meta.properties[pk]);
|
||||
}
|
||||
return meta.hydrateProps;
|
||||
}
|
||||
hydrateProperty(entity, prop, data, factory, newEntity, convertCustomTypes) {
|
||||
entity[prop.name] = data[prop.name];
|
||||
}
|
||||
}
|
||||
57
node_modules/@mikro-orm/core/hydration/ObjectHydrator.d.ts
generated
vendored
Normal file
57
node_modules/@mikro-orm/core/hydration/ObjectHydrator.d.ts
generated
vendored
Normal file
@@ -0,0 +1,57 @@
|
||||
import type { EntityData, EntityMetadata } from '../typings.js';
|
||||
import { Hydrator } from './Hydrator.js';
|
||||
import type { EntityFactory } from '../entity/EntityFactory.js';
|
||||
type EntityHydrator<T extends object> = (
|
||||
entity: T,
|
||||
data: EntityData<T>,
|
||||
factory: EntityFactory,
|
||||
newEntity: boolean,
|
||||
convertCustomTypes: boolean,
|
||||
schema?: string,
|
||||
parentSchema?: string,
|
||||
normalizeAccessors?: boolean,
|
||||
) => void;
|
||||
/** @internal JIT-compiled hydrator that converts raw database rows into entity instances with optimized generated code. */
|
||||
export declare class ObjectHydrator extends Hydrator {
|
||||
#private;
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrate<T extends object>(
|
||||
entity: T,
|
||||
meta: EntityMetadata<T>,
|
||||
data: EntityData<T>,
|
||||
factory: EntityFactory,
|
||||
type: 'full' | 'reference',
|
||||
newEntity?: boolean,
|
||||
convertCustomTypes?: boolean,
|
||||
schema?: string,
|
||||
parentSchema?: string,
|
||||
normalizeAccessors?: boolean,
|
||||
): void;
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrateReference<T extends object>(
|
||||
entity: T,
|
||||
meta: EntityMetadata<T>,
|
||||
data: EntityData<T>,
|
||||
factory: EntityFactory,
|
||||
convertCustomTypes?: boolean,
|
||||
schema?: string,
|
||||
parentSchema?: string,
|
||||
normalizeAccessors?: boolean,
|
||||
): void;
|
||||
/**
|
||||
* @internal Highly performance-sensitive method.
|
||||
*/
|
||||
getEntityHydrator<T extends object>(
|
||||
meta: EntityMetadata<T>,
|
||||
type: 'full' | 'reference',
|
||||
normalizeAccessors?: boolean,
|
||||
): EntityHydrator<T>;
|
||||
private createCollectionItemMapper;
|
||||
private wrap;
|
||||
private safeKey;
|
||||
}
|
||||
export {};
|
||||
499
node_modules/@mikro-orm/core/hydration/ObjectHydrator.js
generated
vendored
Normal file
499
node_modules/@mikro-orm/core/hydration/ObjectHydrator.js
generated
vendored
Normal file
@@ -0,0 +1,499 @@
|
||||
import { Hydrator } from './Hydrator.js';
|
||||
import { Collection } from '../entity/Collection.js';
|
||||
import { Reference, ScalarReference } from '../entity/Reference.js';
|
||||
import { PolymorphicRef } from '../entity/PolymorphicRef.js';
|
||||
import { parseJsonSafe, Utils } from '../utils/Utils.js';
|
||||
import { ReferenceKind } from '../enums.js';
|
||||
import { Raw } from '../utils/RawQueryFragment.js';
|
||||
import { ValidationError } from '../errors.js';
|
||||
/** @internal JIT-compiled hydrator that converts raw database rows into entity instances with optimized generated code. */
|
||||
export class ObjectHydrator extends Hydrator {
|
||||
#hydrators = {
|
||||
'full~true': new Map(),
|
||||
'full~false': new Map(),
|
||||
'reference~true': new Map(),
|
||||
'reference~false': new Map(),
|
||||
};
|
||||
#tmpIndex = 0;
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrate(
|
||||
entity,
|
||||
meta,
|
||||
data,
|
||||
factory,
|
||||
type,
|
||||
newEntity = false,
|
||||
convertCustomTypes = false,
|
||||
schema,
|
||||
parentSchema,
|
||||
normalizeAccessors,
|
||||
) {
|
||||
const hydrate = this.getEntityHydrator(meta, type, normalizeAccessors);
|
||||
const running = this.running;
|
||||
// the running state is used to consider propagation as hydration, saving the values directly to the entity data,
|
||||
// but we don't want that for new entities, their propagation should result in entity updates when flushing
|
||||
this.running = !newEntity;
|
||||
Utils.callCompiledFunction(
|
||||
hydrate,
|
||||
entity,
|
||||
data,
|
||||
factory,
|
||||
newEntity,
|
||||
convertCustomTypes,
|
||||
schema,
|
||||
parentSchema,
|
||||
normalizeAccessors,
|
||||
);
|
||||
this.running = running;
|
||||
}
|
||||
/**
|
||||
* @inheritDoc
|
||||
*/
|
||||
hydrateReference(entity, meta, data, factory, convertCustomTypes = false, schema, parentSchema, normalizeAccessors) {
|
||||
const hydrate = this.getEntityHydrator(meta, 'reference', normalizeAccessors);
|
||||
const running = this.running;
|
||||
this.running = true;
|
||||
Utils.callCompiledFunction(
|
||||
hydrate,
|
||||
entity,
|
||||
data,
|
||||
factory,
|
||||
false,
|
||||
convertCustomTypes,
|
||||
schema,
|
||||
parentSchema,
|
||||
normalizeAccessors,
|
||||
);
|
||||
this.running = running;
|
||||
}
|
||||
/**
|
||||
* @internal Highly performance-sensitive method.
|
||||
*/
|
||||
getEntityHydrator(meta, type, normalizeAccessors = false) {
|
||||
const key = `${type}~${normalizeAccessors}`;
|
||||
const exists = this.#hydrators[key].get(meta.class);
|
||||
if (exists) {
|
||||
return exists;
|
||||
}
|
||||
const lines = [];
|
||||
const context = new Map();
|
||||
const props = this.getProperties(meta, type);
|
||||
context.set('isPrimaryKey', Utils.isPrimaryKey);
|
||||
context.set('Collection', Collection);
|
||||
context.set('Reference', Reference);
|
||||
context.set('PolymorphicRef', PolymorphicRef);
|
||||
context.set('ValidationError', ValidationError);
|
||||
const registerCustomType = (prop, convertorKey, method, context) => {
|
||||
context.set(`${method}_${convertorKey}`, val => {
|
||||
/* v8 ignore next */
|
||||
if (Raw.isKnownFragment(val)) {
|
||||
return val;
|
||||
}
|
||||
return prop.customType[method](val, this.platform, { mode: 'serialization' });
|
||||
});
|
||||
return convertorKey;
|
||||
};
|
||||
const hydrateScalar = (prop, path, dataKey) => {
|
||||
const entityKey = path.map(k => this.wrap(k)).join('');
|
||||
const tz = this.platform.getTimezone();
|
||||
const convertorKey = path
|
||||
.filter(k => !/\[idx_\d+]/.exec(k))
|
||||
.map(k => this.safeKey(k))
|
||||
.join('_');
|
||||
const ret = [];
|
||||
const idx = this.#tmpIndex++;
|
||||
const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
|
||||
if (prop.getter && !prop.setter && prop.persist === false) {
|
||||
return [];
|
||||
}
|
||||
if (prop.ref) {
|
||||
context.set('ScalarReference', ScalarReference);
|
||||
ret.push(` const oldValue_${idx} = entity${entityKey};`);
|
||||
}
|
||||
ret.push(` if (data${dataKey} === null) {`);
|
||||
if (prop.ref) {
|
||||
ret.push(` entity${entityKey} = new ScalarReference();`);
|
||||
ret.push(` entity${entityKey}.bind(entity, '${prop.name}');`);
|
||||
ret.push(` entity${entityKey}.set(${nullVal});`);
|
||||
} else {
|
||||
ret.push(` entity${entityKey} = ${nullVal};`);
|
||||
}
|
||||
ret.push(` } else if (typeof data${dataKey} !== 'undefined') {`);
|
||||
if (prop.customType) {
|
||||
registerCustomType(prop, convertorKey, 'convertToJSValue', context);
|
||||
registerCustomType(prop, convertorKey, 'convertToDatabaseValue', context);
|
||||
ret.push(
|
||||
` if (convertCustomTypes) {`,
|
||||
` const value = convertToJSValue_${convertorKey}(data${dataKey});`,
|
||||
);
|
||||
if (prop.customType.ensureComparable(meta, prop)) {
|
||||
ret.push(` data${dataKey} = convertToDatabaseValue_${convertorKey}(value);`);
|
||||
}
|
||||
ret.push(
|
||||
` entity${entityKey} = value;`,
|
||||
` } else {`,
|
||||
` entity${entityKey} = data${dataKey};`,
|
||||
` }`,
|
||||
);
|
||||
} else if (prop.runtimeType === 'boolean') {
|
||||
ret.push(` entity${entityKey} = !!data${dataKey};`);
|
||||
} else if (prop.runtimeType === 'Date' && !this.platform.isNumericProperty(prop)) {
|
||||
ret.push(` if (data${dataKey} instanceof Date) {`);
|
||||
ret.push(` entity${entityKey} = data${dataKey};`);
|
||||
if (!tz || tz === 'local') {
|
||||
ret.push(` } else {`);
|
||||
ret.push(` entity${entityKey} = new Date(data${dataKey});`);
|
||||
} else {
|
||||
ret.push(
|
||||
` } else if (typeof data${dataKey} === 'number' || data${dataKey}.includes('+') || data${dataKey}.lastIndexOf('-') > 10 || data${dataKey}.endsWith('Z')) {`,
|
||||
);
|
||||
ret.push(` entity${entityKey} = new Date(data${dataKey});`);
|
||||
ret.push(` } else {`);
|
||||
ret.push(` entity${entityKey} = new Date(data${dataKey} + '${tz}');`);
|
||||
}
|
||||
ret.push(` }`);
|
||||
} else {
|
||||
ret.push(` entity${entityKey} = data${dataKey};`);
|
||||
}
|
||||
if (prop.ref) {
|
||||
ret.push(` const value = entity${entityKey};`);
|
||||
ret.push(` entity${entityKey} = oldValue_${idx} ?? new ScalarReference(value);`);
|
||||
ret.push(` entity${entityKey}.bind(entity, '${prop.name}');`);
|
||||
ret.push(` entity${entityKey}.set(value);`);
|
||||
}
|
||||
ret.push(` }`);
|
||||
if (prop.ref) {
|
||||
ret.push(` if (!entity${entityKey}) {`);
|
||||
ret.push(` entity${entityKey} = new ScalarReference();`);
|
||||
ret.push(` entity${entityKey}.bind(entity, '${prop.name}');`);
|
||||
ret.push(` }`);
|
||||
}
|
||||
return ret;
|
||||
};
|
||||
const hydrateToOne = (prop, dataKey, entityKey) => {
|
||||
const ret = [];
|
||||
const method = type === 'reference' ? 'createReference' : 'create';
|
||||
const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
|
||||
ret.push(` if (data${dataKey} === null) {\n entity${entityKey} = ${nullVal};`);
|
||||
ret.push(` } else if (typeof data${dataKey} !== 'undefined') {`);
|
||||
// For polymorphic: instanceof check; for regular: isPrimaryKey() check
|
||||
const pkCheck = prop.polymorphic
|
||||
? `data${dataKey} instanceof PolymorphicRef`
|
||||
: `isPrimaryKey(data${dataKey}, true)`;
|
||||
ret.push(` if (${pkCheck}) {`);
|
||||
// When targetKey is set, pass the key option to createReference so it uses the alternate key
|
||||
const keyOption = prop.targetKey ? `, key: '${prop.targetKey}'` : '';
|
||||
if (prop.polymorphic) {
|
||||
// For polymorphic: target class from discriminator map, PK from data.id
|
||||
const discriminatorMapKey = this.safeKey(`discriminatorMap_${prop.name}_${this.#tmpIndex++}`);
|
||||
context.set(discriminatorMapKey, prop.discriminatorMap);
|
||||
ret.push(` const targetClass = ${discriminatorMapKey}[data${dataKey}.discriminator];`);
|
||||
ret.push(
|
||||
` if (!targetClass) throw new ValidationError(\`Unknown discriminator value '\${data${dataKey}.discriminator}' for polymorphic relation '${prop.name}'. Valid values: \${Object.keys(${discriminatorMapKey}).join(', ')}\`);`,
|
||||
);
|
||||
if (prop.ref) {
|
||||
ret.push(
|
||||
` entity${entityKey} = Reference.create(factory.createReference(targetClass, data${dataKey}.id, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} }));`,
|
||||
);
|
||||
} else {
|
||||
ret.push(
|
||||
` entity${entityKey} = factory.createReference(targetClass, data${dataKey}.id, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} });`,
|
||||
);
|
||||
}
|
||||
} else {
|
||||
// For regular: fixed target class, PK is the data itself
|
||||
const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
|
||||
context.set(targetKey, prop.targetMeta.class);
|
||||
if (prop.ref) {
|
||||
ret.push(
|
||||
` entity${entityKey} = Reference.create(factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} }));`,
|
||||
);
|
||||
} else {
|
||||
ret.push(
|
||||
` entity${entityKey} = factory.createReference(${targetKey}, data${dataKey}, { merge: true, convertCustomTypes, normalizeAccessors, schema${keyOption} });`,
|
||||
);
|
||||
}
|
||||
}
|
||||
ret.push(` } else if (data${dataKey} && typeof data${dataKey} === 'object') {`);
|
||||
// For full entity hydration, polymorphic needs to determine target class from entity itself
|
||||
let hydrateTargetExpr;
|
||||
if (prop.polymorphic) {
|
||||
hydrateTargetExpr = `data${dataKey}.constructor`;
|
||||
} else {
|
||||
const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
|
||||
context.set(targetKey, prop.targetMeta.class);
|
||||
hydrateTargetExpr = targetKey;
|
||||
}
|
||||
if (prop.ref) {
|
||||
ret.push(
|
||||
` entity${entityKey} = Reference.create(factory.${method}(${hydrateTargetExpr}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema }));`,
|
||||
);
|
||||
} else {
|
||||
ret.push(
|
||||
` entity${entityKey} = factory.${method}(${hydrateTargetExpr}, data${dataKey}, { initialized: true, merge: true, newEntity, convertCustomTypes, normalizeAccessors, schema });`,
|
||||
);
|
||||
}
|
||||
ret.push(` }`);
|
||||
ret.push(` }`);
|
||||
if (prop.kind === ReferenceKind.ONE_TO_ONE) {
|
||||
const meta2 = this.metadata.get(prop.targetMeta.class);
|
||||
const prop2 = meta2.properties[prop.inversedBy || prop.mappedBy];
|
||||
if (prop2 && !prop2.mapToPk) {
|
||||
ret.push(` if (data${dataKey} && entity${entityKey} && !entity${entityKey}.${this.safeKey(prop2.name)}) {`);
|
||||
ret.push(
|
||||
` entity${entityKey}.${prop.ref ? 'unwrap().' : ''}${this.safeKey(prop2.name)} = ${prop2.ref ? 'Reference.create(entity)' : 'entity'};`,
|
||||
);
|
||||
ret.push(` }`);
|
||||
}
|
||||
}
|
||||
if (prop.customType?.ensureComparable(meta, prop)) {
|
||||
registerCustomType(prop, this.safeKey(prop.name), 'convertToDatabaseValue', context);
|
||||
ret.push(` if (data${dataKey} != null && typeof data${dataKey} !== 'object' && convertCustomTypes) {`);
|
||||
ret.push(
|
||||
` data${dataKey} = convertToDatabaseValue_${this.safeKey(prop.name)}(entity${entityKey}.__helper.getPrimaryKey());`,
|
||||
);
|
||||
ret.push(` }`);
|
||||
}
|
||||
return ret;
|
||||
};
|
||||
const hydrateToMany = (prop, dataKey, entityKey) => {
|
||||
const ret = [];
|
||||
ret.push(...this.createCollectionItemMapper(prop, context));
|
||||
ret.push(` if (data${dataKey} && !Array.isArray(data${dataKey}) && typeof data${dataKey} === 'object') {`);
|
||||
ret.push(` data${dataKey} = [data${dataKey}];`);
|
||||
ret.push(` }`);
|
||||
ret.push(` if (Array.isArray(data${dataKey})) {`);
|
||||
ret.push(
|
||||
` const items = data${dataKey}.map(value => createCollectionItem_${this.safeKey(prop.name)}(value, entity));`,
|
||||
);
|
||||
ret.push(` const coll = Collection.create(entity, '${prop.name}', items, newEntity);`);
|
||||
ret.push(` if (newEntity) {`);
|
||||
ret.push(` coll.setDirty();`);
|
||||
ret.push(` } else {`);
|
||||
ret.push(` coll.takeSnapshot(true);`);
|
||||
ret.push(` }`);
|
||||
ret.push(` } else if (!entity${entityKey} && data${dataKey} instanceof Collection) {`);
|
||||
ret.push(` entity${entityKey} = data${dataKey};`);
|
||||
if (!this.platform.usesPivotTable() && prop.owner && prop.kind === ReferenceKind.MANY_TO_MANY) {
|
||||
ret.push(` } else if (!entity${entityKey} && Array.isArray(data${dataKey})) {`);
|
||||
const items = this.platform.usesPivotTable() || !prop.owner ? 'undefined' : '[]';
|
||||
ret.push(
|
||||
` const coll = Collection.create(entity, '${prop.name}', ${items}, !!data${dataKey} || newEntity);`,
|
||||
);
|
||||
ret.push(` coll.setDirty(false);`);
|
||||
}
|
||||
ret.push(` } else if (!entity${entityKey}) {`);
|
||||
ret.push(` const coll = Collection.create(entity, '${prop.name}', undefined, newEntity);`);
|
||||
ret.push(` coll.setDirty(false);`);
|
||||
ret.push(` }`);
|
||||
return ret;
|
||||
};
|
||||
const registerEmbeddedPrototype = (prop, path) => {
|
||||
const convertorKey = path
|
||||
.filter(k => !/\[idx_\d+]/.exec(k))
|
||||
.map(k => this.safeKey(k))
|
||||
.join('_');
|
||||
if (prop.targetMeta?.polymorphs) {
|
||||
prop.targetMeta.polymorphs.forEach(meta => {
|
||||
context.set(`prototype_${convertorKey}_${meta.className}`, meta.prototype);
|
||||
});
|
||||
} else {
|
||||
context.set(`prototype_${convertorKey}`, prop.embeddable.prototype);
|
||||
}
|
||||
};
|
||||
const parseObjectEmbeddable = (prop, dataKey, ret) => {
|
||||
if (!this.platform.convertsJsonAutomatically() && (prop.object || prop.array)) {
|
||||
context.set('parseJsonSafe', parseJsonSafe);
|
||||
ret.push(
|
||||
` if (typeof data${dataKey} === 'string') {`,
|
||||
` data${dataKey} = parseJsonSafe(data${dataKey});`,
|
||||
` }`,
|
||||
);
|
||||
}
|
||||
};
|
||||
const createCond = (prop, dataKey, cond) => {
|
||||
const conds = [];
|
||||
if (prop.object) {
|
||||
conds.push(`data${dataKey} ${cond ?? '!= null'}`);
|
||||
} else {
|
||||
const notNull = cond ?? (prop.nullable ? '!= null' : '!== undefined');
|
||||
meta.props
|
||||
.filter(p => p.embedded?.[0] === prop.name)
|
||||
.forEach(p => {
|
||||
if (p.kind === ReferenceKind.EMBEDDED && !p.object && !p.array) {
|
||||
conds.push(...createCond(p, dataKey + this.wrap(p.embedded[1]), cond));
|
||||
return;
|
||||
}
|
||||
conds.push(`data${this.wrap(p.name)} ${notNull}`);
|
||||
});
|
||||
}
|
||||
return conds;
|
||||
};
|
||||
const hydrateEmbedded = (prop, path, dataKey) => {
|
||||
const entityKey = path.map(k => this.wrap(k)).join('');
|
||||
const ret = [];
|
||||
registerEmbeddedPrototype(prop, path);
|
||||
parseObjectEmbeddable(prop, dataKey, ret);
|
||||
ret.push(` if (${createCond(prop, dataKey).join(' || ')}) {`);
|
||||
if (prop.object) {
|
||||
ret.push(` const embeddedData = data${dataKey};`);
|
||||
} else {
|
||||
ret.push(` const embeddedData = {`);
|
||||
for (const childProp of Object.values(prop.embeddedProps)) {
|
||||
const key = /^\w+$/.exec(childProp.embedded[1]) ? childProp.embedded[1] : `'${childProp.embedded[1]}'`;
|
||||
ret.push(` ${key}: data${this.wrap(childProp.name)},`);
|
||||
}
|
||||
ret.push(` };`);
|
||||
}
|
||||
if (prop.targetMeta?.polymorphs) {
|
||||
prop.targetMeta.polymorphs.forEach(childMeta => {
|
||||
const childProp = prop.embeddedProps[prop.targetMeta.discriminatorColumn];
|
||||
const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
|
||||
context.set(childMeta.className, childMeta.class);
|
||||
// weak comparison as we can have numbers that might have been converted to strings due to being object keys
|
||||
ret.push(` if (data${childDataKey} == '${childMeta.discriminatorValue}') {`);
|
||||
ret.push(` if (entity${entityKey} == null) {`);
|
||||
ret.push(
|
||||
` entity${entityKey} = factory.createEmbeddable(${childMeta.className}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`,
|
||||
);
|
||||
ret.push(` }`);
|
||||
meta.props
|
||||
.filter(p => p.embedded?.[0] === prop.name)
|
||||
.forEach(childProp => {
|
||||
const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
|
||||
const prop2 = childMeta.properties[childProp.embedded[1]];
|
||||
const prop3 = {
|
||||
...prop2,
|
||||
name: childProp.name,
|
||||
embedded: childProp.embedded,
|
||||
embeddedProps: childProp.embeddedProps,
|
||||
};
|
||||
ret.push(
|
||||
// eslint-disable-next-line @typescript-eslint/no-use-before-define, no-use-before-define
|
||||
...hydrateProperty(prop3, childProp.object, [...path, childProp.embedded[1]], childDataKey).map(
|
||||
l => ' ' + l,
|
||||
),
|
||||
);
|
||||
});
|
||||
ret.push(` }`);
|
||||
});
|
||||
} else {
|
||||
const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
|
||||
context.set(targetKey, prop.targetMeta.class);
|
||||
ret.push(` if (entity${entityKey} == null) {`);
|
||||
ret.push(
|
||||
` entity${entityKey} = factory.createEmbeddable(${targetKey}, embeddedData, { newEntity, convertCustomTypes, normalizeAccessors });`,
|
||||
);
|
||||
ret.push(` }`);
|
||||
meta.props
|
||||
.filter(p => p.embedded?.[0] === prop.name)
|
||||
.forEach(childProp => {
|
||||
const childDataKey = prop.object ? dataKey + this.wrap(childProp.embedded[1]) : this.wrap(childProp.name);
|
||||
ret.push(
|
||||
// eslint-disable-next-line @typescript-eslint/no-use-before-define, no-use-before-define
|
||||
...hydrateProperty(childProp, prop.object, [...path, childProp.embedded[1]], childDataKey).map(
|
||||
l => ' ' + l,
|
||||
),
|
||||
);
|
||||
});
|
||||
}
|
||||
/* v8 ignore next */
|
||||
const nullVal = this.config.get('forceUndefined') ? 'undefined' : 'null';
|
||||
if (prop.object) {
|
||||
ret.push(` } else if (data${dataKey} === null) {`);
|
||||
} else {
|
||||
ret.push(` } else if (${createCond(prop, dataKey, '=== null').join(' && ')}) {`);
|
||||
}
|
||||
ret.push(` entity${entityKey} = ${nullVal};`);
|
||||
ret.push(` }`);
|
||||
return ret;
|
||||
};
|
||||
const hydrateEmbeddedArray = (prop, path, dataKey) => {
|
||||
const entityKey = path.map(k => this.wrap(k)).join('');
|
||||
const ret = [];
|
||||
const idx = this.#tmpIndex++;
|
||||
registerEmbeddedPrototype(prop, path);
|
||||
parseObjectEmbeddable(prop, dataKey, ret);
|
||||
ret.push(` if (Array.isArray(data${dataKey})) {`);
|
||||
ret.push(` entity${entityKey} = [];`);
|
||||
ret.push(` data${dataKey}.forEach((_, idx_${idx}) => {`);
|
||||
ret.push(...hydrateEmbedded(prop, [...path, `[idx_${idx}]`], `${dataKey}[idx_${idx}]`).map(l => ' ' + l));
|
||||
ret.push(` });`);
|
||||
ret.push(` }`);
|
||||
return ret;
|
||||
};
|
||||
const hydrateProperty = (prop, object = prop.object, path = [prop.name], dataKey) => {
|
||||
const entityKey = path.map(k => this.wrap(k)).join('');
|
||||
dataKey =
|
||||
dataKey ?? (object ? entityKey : this.wrap(normalizeAccessors ? (prop.accessor ?? prop.name) : prop.name));
|
||||
const ret = [];
|
||||
if ([ReferenceKind.MANY_TO_ONE, ReferenceKind.ONE_TO_ONE].includes(prop.kind) && !prop.mapToPk) {
|
||||
ret.push(...hydrateToOne(prop, dataKey, entityKey));
|
||||
} else if (prop.kind === ReferenceKind.ONE_TO_MANY || prop.kind === ReferenceKind.MANY_TO_MANY) {
|
||||
ret.push(...hydrateToMany(prop, dataKey, entityKey));
|
||||
} else if (prop.kind === ReferenceKind.EMBEDDED) {
|
||||
if (prop.array) {
|
||||
ret.push(...hydrateEmbeddedArray(prop, path, dataKey));
|
||||
} else {
|
||||
ret.push(...hydrateEmbedded(prop, path, dataKey));
|
||||
if (!prop.object) {
|
||||
ret.push(...hydrateEmbedded({ ...prop, object: true }, path, dataKey));
|
||||
}
|
||||
}
|
||||
} else {
|
||||
// ReferenceKind.SCALAR
|
||||
ret.push(...hydrateScalar(prop, path, dataKey));
|
||||
}
|
||||
if (this.config.get('forceUndefined')) {
|
||||
ret.push(` if (data${dataKey} === null) entity${entityKey} = undefined;`);
|
||||
}
|
||||
return ret;
|
||||
};
|
||||
for (const prop of props) {
|
||||
lines.push(...hydrateProperty(prop));
|
||||
}
|
||||
const code =
|
||||
`// compiled hydrator for entity ${meta.className} (${type + normalizeAccessors ? ' normalized' : ''})\n` +
|
||||
`return function(entity, data, factory, newEntity, convertCustomTypes, schema, parentSchema, normalizeAccessors) {\n` +
|
||||
`${lines.join('\n')}\n}`;
|
||||
const fnKey = `hydrator-${meta.uniqueName}-${type}-${normalizeAccessors}`;
|
||||
const hydrator = Utils.createFunction(context, code, this.config.get('compiledFunctions'), fnKey);
|
||||
this.#hydrators[key].set(meta.class, hydrator);
|
||||
return hydrator;
|
||||
}
|
||||
createCollectionItemMapper(prop, context) {
|
||||
const meta = this.metadata.get(prop.targetMeta.class);
|
||||
const lines = [];
|
||||
lines.push(` const createCollectionItem_${this.safeKey(prop.name)} = (value, entity) => {`);
|
||||
const prop2 = prop.targetMeta.properties[prop.mappedBy];
|
||||
if (prop.kind === ReferenceKind.ONE_TO_MANY && prop2.primary) {
|
||||
lines.push(` if (typeof value === 'object' && value?.['${prop2.name}'] == null) {`);
|
||||
lines.push(
|
||||
` value = { ...value, ['${prop2.name}']: Reference.wrapReference(entity, { ref: ${prop2.ref} }) };`,
|
||||
);
|
||||
lines.push(` }`);
|
||||
}
|
||||
const targetKey = this.safeKey(`${prop.targetMeta.tableName}_${this.#tmpIndex++}`);
|
||||
context.set(targetKey, prop.targetMeta.class);
|
||||
lines.push(
|
||||
` if (isPrimaryKey(value, ${meta.compositePK})) return factory.createReference(${targetKey}, value, { convertCustomTypes, schema, normalizeAccessors, merge: true });`,
|
||||
);
|
||||
lines.push(` if (value && value.__entity) return value;`);
|
||||
lines.push(
|
||||
` return factory.create(${targetKey}, value, { newEntity, convertCustomTypes, schema, normalizeAccessors, merge: true });`,
|
||||
);
|
||||
lines.push(` }`);
|
||||
return lines;
|
||||
}
|
||||
wrap(key) {
|
||||
if (/^\[.*]$/.exec(key)) {
|
||||
return key;
|
||||
}
|
||||
return /^\w+$/.exec(key) ? `.${key}` : `['${key}']`;
|
||||
}
|
||||
safeKey(key) {
|
||||
return key.replace(/\W/g, '_');
|
||||
}
|
||||
}
|
||||
2
node_modules/@mikro-orm/core/hydration/index.d.ts
generated
vendored
Normal file
2
node_modules/@mikro-orm/core/hydration/index.d.ts
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
export * from './Hydrator.js';
|
||||
export * from './ObjectHydrator.js';
|
||||
2
node_modules/@mikro-orm/core/hydration/index.js
generated
vendored
Normal file
2
node_modules/@mikro-orm/core/hydration/index.js
generated
vendored
Normal file
@@ -0,0 +1,2 @@
|
||||
export * from './Hydrator.js';
|
||||
export * from './ObjectHydrator.js';
|
||||
Reference in New Issue
Block a user