joist-core 2.3.0 → 2.4.0

package/build/getProperties.cjs

@@ -0,0 +1,87 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_utils = require("./utils.cjs");
+const require_newEntity = require("./newEntity.cjs");
+require("./EntityMetadata.cjs");
+const require_BaseEntity = require("./BaseEntity.cjs");
+//#region src/getProperties.ts
+/**
+* Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.
+*
+* This is a little tricky because field assignments don't show up on the prototype, so we actually
+* instantiate a throw-away instance to observe the side-effect of what fields it has.
+*
+* The map values will be:
+*
+* - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations
+* - The primitive value like true/false/"foo" for getters that return primitive values
+* - A `UnknownProperty` for keys/getters that return `undefined` or throw errors
+* - Any other custom value that the user has defined
+*
+* Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`
+* checks.
+*/
+function getProperties(meta) {
+	const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;
+	if (propertiesCache[key]) return propertiesCache[key];
+	const cached = propertiesCache[key] = {};
+	const instance = new meta.cstr(void 0, true);
+	const knownPrimitives = Object.values(meta.allFields).filter((f) => f.kind === "primaryKey" || f.kind === "primitive" || f.kind === "enum").map((f) => f.fieldName);
+	const [relationFields, otherFields] = require_utils.partition(Object.entries(instance), ([, value]) => value instanceof require_newEntity.LazyRelation);
+	const invalidFields = otherFields.filter(([fieldName]) => fieldName !== "transientFields");
+	if (invalidFields.length > 0) throw new Error(`${meta.type} has invalid class fields, ${invalidFields.map(([k]) => k).join(", ")} should go in transientFields`);
+	const properties = [...relationFields, ...getRecursivePrototypeKeys(instance).filter((key) => !knownPrimitives.includes(key)).map((key) => {
+		try {
+			return [key, instance[key] ?? unknown];
+		} catch {
+			return [key, unknown];
+		}
+	})];
+	lazyFields[key] = [...relationFields, ...otherFields];
+	Object.assign(cached, Object.fromEntries(properties.map(([fieldName, value]) => [fieldName, value instanceof require_newEntity.LazyRelation ? value.create(instance, fieldName) : value])));
+	Object.setPrototypeOf(instance, afterGetPropertiesInstancePrototypeProxy);
+	for (const prop of Object.getOwnPropertyNames(instance)) if (prop !== "__data") delete instance[prop];
+	return cached;
+}
+const afterGetPropertiesInstancePrototypeProxy = new Proxy({}, { get: () => require_utils.fail("Cannot use 'this' in a property callback") });
+/**
+* Returns the `LazyRelation`s (...and transientField) for `meta`.
+*
+* Should only be used by `newEntity` while moving relations to the prototype.
+*/
+function getLazyFields(meta) {
+	getProperties(meta);
+	const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;
+	return lazyFields[key];
+}
+var UnknownProperty = class {};
+const unknown = new UnknownProperty();
+const propertiesCache = {};
+const lazyFields = {};
+const ignoredKeys = /* @__PURE__ */ new Set([
+	"constructor",
+	"id",
+	"idMaybe",
+	"idTagged",
+	"idTaggedMaybe",
+	"set",
+	"setPartial",
+	"setDeepPartial",
+	"changes",
+	"isSoftDeletedEntity",
+	"softDelete",
+	"load",
+	"populate",
+	"isLoaded",
+	"toJSON"
+]);
+function getRecursivePrototypeKeys(instance) {
+	const keys = [];
+	for (let curr = Object.getPrototypeOf(instance); curr && curr !== require_BaseEntity.BaseEntity.prototype; curr = Object.getPrototypeOf(curr)) for (const name of Object.getOwnPropertyNames(curr)) if (!ignoredKeys.has(name)) keys.push(name);
+	return keys;
+}
+//#endregion
+exports.UnknownProperty = UnknownProperty;
+exports.getLazyFields = getLazyFields;
+exports.getProperties = getProperties;
+
+//# sourceMappingURL=getProperties.cjs.map

package/build/getProperties.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"getProperties.cjs","names":["partition","LazyRelation","fail","BaseEntity"],"sources":["../src/getProperties.ts"],"sourcesContent":["import { BaseEntity } from \"src/BaseEntity.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { LazyRelation } from \"src/newEntity.ts\";\nimport { fail, partition } from \"src/utils.ts\";\n\n/**\n * Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.\n *\n * This is a little tricky because field assignments don't show up on the prototype, so we actually\n * instantiate a throw-away instance to observe the side-effect of what fields it has.\n *\n * The map values will be:\n *\n * - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations\n * - The primitive value like true/false/\"foo\" for getters that return primitive values\n * - A `UnknownProperty` for keys/getters that return `undefined` or throw errors\n * - Any other custom value that the user has defined\n *\n * Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`\n * checks.\n */\nexport function getProperties(meta: EntityMetadata): Record<string, any> {\n  // If meta is an STI subtype, give it a different key\n  const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;\n  if (propertiesCache[key]) {\n    return propertiesCache[key];\n  }\n\n  // Immediately populate key to avoid infinite loops when we later call `instance[key]` to probe\n  // for properties, and we end up calling a getter than invokes a ReactiveField/anything else that\n  // happens to ask for properties.\n  // The caller will admittedly see incorrect (empty) properties, but we generally expect these \"evaled\n  // on fake instances\" getters to throw nonsense errors anyway (which we suppress), so it should be fine.\n  const cached = (propertiesCache[key] = {});\n\n  const fakeEm = undefined as any;\n  const instance = new (meta.cstr as any)(fakeEm, true);\n\n  // Mostly for historical reasons, we don't treat known primitives/enums as properties,\n  // i.e. properties were originally meant to be the wrapper objects like `hasOne`,\n  // `hasMany`, `ReactiveField`, etc.\n  //\n  // That said, we've since start leaking other things like getters, regular async methods,\n  // etc., into properties, so that `entityResolver` can pick them up as keys to put into\n  // the GraphQL resolvers. So we should probably just remove this filter and let everything\n  // get returned as properties.\n  const knownPrimitives = Object.values(meta.allFields)\n    .filter((f) => f.kind === \"primaryKey\" || f.kind === \"primitive\" || f.kind === \"enum\")\n    .map((f) => f.fieldName);\n\n  // We can look directly at the `instance` to find all relations (`has...` calls), and any other\n  // instance-level fields (of which only the special `transientFields` is expected/allowed).\n  const [relationFields, otherFields] = partition(\n    Object.entries(instance),\n    ([, value]) => value instanceof LazyRelation,\n  );\n\n  // Enforce transientFields usage\n  const invalidFields = otherFields.filter(([fieldName]) => fieldName !== \"transientFields\");\n  if (invalidFields.length > 0) {\n    throw new Error(\n      `${meta.type} has invalid class fields, ${invalidFields.map(([k]) => k).join(\", \")} should go in transientFields`,\n    );\n  }\n\n  const properties = [\n    // Include the instance-level relations that will be getter-ized by `newEntity`\n    ...relationFields,\n    // And then any prototype-level getters/methods like `isRed` by recursively looking for ownKeys\n    // (this is the previously-mentioned nod to entityResolver to let it copy over getters/methods).\n    ...getRecursivePrototypeKeys(instance)\n      .filter((key) => !knownPrimitives.includes(key))\n      .map((key) => {\n        try {\n          return [key, (instance as any)[key] ?? unknown];\n        } catch {\n          return [key, unknown];\n        }\n      }),\n  ];\n\n  // Keep one version with the relations still lazy, solely for `newEntity`\n  // (technically newEntity will only ask for this once-per-cstr, so a cache is kind of over-kill,\n  // but creating it here, right before we `relationCstr.create`, is a convenient spot).\n  lazyFields[key] = [...relationFields, ...otherFields];\n\n  // But expose to everyone else the concrete/constructed relations\n  Object.assign(\n    cached,\n    Object.fromEntries(\n      properties.map(([fieldName, value]) => [\n        fieldName,\n        value instanceof LazyRelation ? value.create(instance, fieldName) : value,\n      ]),\n    ),\n  );\n\n  // Since our fake instance is actually generating the callbacks for our lazy fields, it will be captured in any\n  // lambdas created.  If any of them reference `this`, then they'll actually be referencing the fake instance.  So we\n  // need to clear out any properties directly on the fake instance now that we're done with it and use a proxy to\n  // intercept any attempts to access `this` from within the callbacks and fail.\n  Object.setPrototypeOf(instance, afterGetPropertiesInstancePrototypeProxy);\n  for (const prop of Object.getOwnPropertyNames(instance)) {\n    if (prop !== \"__data\") delete instance[prop];\n  }\n\n  return cached;\n}\n\nconst afterGetPropertiesInstancePrototypeProxy = new Proxy(\n  {},\n  { get: () => fail(\"Cannot use 'this' in a property callback\") },\n);\n\n/**\n * Returns the `LazyRelation`s (...and transientField) for `meta`.\n *\n * Should only be used by `newEntity` while moving relations to the prototype.\n */\nexport function getLazyFields(meta: EntityMetadata): [string, LazyRelation<any> | object][] {\n  getProperties(meta); // We populate the lazyFields during getProperties\n  const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;\n  return lazyFields[key];\n}\n\nexport class UnknownProperty {}\nconst unknown = new UnknownProperty();\n\nconst propertiesCache: Record<string, any> = {};\nconst lazyFields: Record<string, any> = {};\n\n// These are keys we codegen into `AuthorCodegen` files to get the best typing\n// experience, but really should be treated as BaseEntity keys that we don't\n// need to expose from `getProperties`.\nconst ignoredKeys = new Set([\n  \"constructor\",\n  \"id\",\n  \"idMaybe\",\n  \"idTagged\",\n  \"idTaggedMaybe\",\n  \"set\",\n  \"setPartial\",\n  \"setDeepPartial\",\n  \"changes\",\n  \"isSoftDeletedEntity\",\n  \"softDelete\",\n  \"load\",\n  \"populate\",\n  \"isLoaded\",\n  \"toJSON\",\n]);\n\nfunction getRecursivePrototypeKeys(instance: any): string[] {\n  const keys: string[] = [];\n  for (\n    let curr = Object.getPrototypeOf(instance);\n    curr && curr !== BaseEntity.prototype;\n    curr = Object.getPrototypeOf(curr)\n  ) {\n    for (const name of Object.getOwnPropertyNames(curr)) {\n      if (!ignoredKeys.has(name)) {\n        keys.push(name);\n      }\n    }\n  }\n  return keys;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,cAAc,MAA2C;CAEvE,MAAM,MAAM,KAAK,wBAAwB,GAAG,KAAK,UAAU,GAAG,KAAK,0BAA0B,KAAK;CAClG,IAAI,gBAAgB,MAClB,OAAO,gBAAgB;CAQzB,MAAM,SAAU,gBAAgB,OAAO,CAAC;CAGxC,MAAM,WAAW,IAAK,KAAK,KAAa,KAAA,GAAQ,IAAI;CAUpD,MAAM,kBAAkB,OAAO,OAAO,KAAK,SAAS,CAAC,CAClD,QAAQ,MAAM,EAAE,SAAS,gBAAgB,EAAE,SAAS,eAAe,EAAE,SAAS,MAAM,CAAC,CACrF,KAAK,MAAM,EAAE,SAAS;CAIzB,MAAM,CAAC,gBAAgB,eAAeA,cAAAA,UACpC,OAAO,QAAQ,QAAQ,IACtB,GAAG,WAAW,iBAAiBC,kBAAAA,YAClC;CAGA,MAAM,gBAAgB,YAAY,QAAQ,CAAC,eAAe,cAAc,iBAAiB;CACzF,IAAI,cAAc,SAAS,GACzB,MAAM,IAAI,MACR,GAAG,KAAK,KAAK,6BAA6B,cAAc,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,8BACrF;CAGF,MAAM,aAAa,CAEjB,GAAG,gBAGH,GAAG,0BAA0B,QAAQ,CAAC,CACnC,QAAQ,QAAQ,CAAC,gBAAgB,SAAS,GAAG,CAAC,CAAC,CAC/C,KAAK,QAAQ;EACZ,IAAI;GACF,OAAO,CAAC,KAAM,SAAiB,QAAQ,OAAO;EAChD,QAAQ;GACN,OAAO,CAAC,KAAK,OAAO;EACtB;CACF,CAAC,CACL;CAKA,WAAW,OAAO,CAAC,GAAG,gBAAgB,GAAG,WAAW;CAGpD,OAAO,OACL,QACA,OAAO,YACL,WAAW,KAAK,CAAC,WAAW,WAAW,CACrC,WACA,iBAAiBA,kBAAAA,eAAe,MAAM,OAAO,UAAU,SAAS,IAAI,KACtE,CAAC,CACH,CACF;CAMA,OAAO,eAAe,UAAU,wCAAwC;CACxE,KAAK,MAAM,QAAQ,OAAO,oBAAoB,QAAQ,GACpD,IAAI,SAAS,UAAU,OAAO,SAAS;CAGzC,OAAO;AACT;AAEA,MAAM,2CAA2C,IAAI,MACnD,CAAC,GACD,EAAE,WAAWC,cAAAA,KAAK,0CAA0C,EAAE,CAChE;;;;;;AAOA,SAAgB,cAAc,MAA8D;CAC1F,cAAc,IAAI;CAClB,MAAM,MAAM,KAAK,wBAAwB,GAAG,KAAK,UAAU,GAAG,KAAK,0BAA0B,KAAK;CAClG,OAAO,WAAW;AACpB;AAEA,IAAa,kBAAb,MAA6B,CAAC;AAC9B,MAAM,UAAU,IAAI,gBAAgB;AAEpC,MAAM,kBAAuC,CAAC;AAC9C,MAAM,aAAkC,CAAC;AAKzC,MAAM,8BAAc,IAAI,IAAI;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,SAAS,0BAA0B,UAAyB;CAC1D,MAAM,OAAiB,CAAC;CACxB,KACE,IAAI,OAAO,OAAO,eAAe,QAAQ,GACzC,QAAQ,SAASC,mBAAAA,WAAW,WAC5B,OAAO,OAAO,eAAe,IAAI,GAEjC,KAAK,MAAM,QAAQ,OAAO,oBAAoB,IAAI,GAChD,IAAI,CAAC,YAAY,IAAI,IAAI,GACvB,KAAK,KAAK,IAAI;CAIpB,OAAO;AACT"}

package/build/getProperties.d.cts

@@ -0,0 +1,30 @@
+import { EntityMetadata } from "./EntityMetadata.cjs";
+import { LazyRelation } from "./newEntity.cjs";
+//#region src/getProperties.d.ts
+/**
+ * Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.
+ *
+ * This is a little tricky because field assignments don't show up on the prototype, so we actually
+ * instantiate a throw-away instance to observe the side-effect of what fields it has.
+ *
+ * The map values will be:
+ *
+ * - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations
+ * - The primitive value like true/false/"foo" for getters that return primitive values
+ * - A `UnknownProperty` for keys/getters that return `undefined` or throw errors
+ * - Any other custom value that the user has defined
+ *
+ * Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`
+ * checks.
+ */
+declare function getProperties(meta: EntityMetadata): Record<string, any>;
+/**
+ * Returns the `LazyRelation`s (...and transientField) for `meta`.
+ *
+ * Should only be used by `newEntity` while moving relations to the prototype.
+ */
+declare function getLazyFields(meta: EntityMetadata): [string, LazyRelation<any> | object][];
+declare class UnknownProperty {}
+//#endregion
+export { UnknownProperty, getLazyFields, getProperties };
+//# sourceMappingURL=getProperties.d.cts.map

package/build/getProperties.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getProperties.d.cts","names":[],"sources":["../src/getProperties.ts"],"mappings":";;;;;;;;;;;;;;;;;;;iBAqBgB,cAAc,MAAM,iBAAiB;;;;;;iBAkGrC,cAAc,MAAM,0BAA0B;cAMjD"}

package/build/getProperties.d.mts

@@ -0,0 +1,30 @@
+import { EntityMetadata } from "./EntityMetadata.mjs";
+import { LazyRelation } from "./newEntity.mjs";
+//#region src/getProperties.d.ts
+/**
+ * Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.
+ *
+ * This is a little tricky because field assignments don't show up on the prototype, so we actually
+ * instantiate a throw-away instance to observe the side-effect of what fields it has.
+ *
+ * The map values will be:
+ *
+ * - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations
+ * - The primitive value like true/false/"foo" for getters that return primitive values
+ * - A `UnknownProperty` for keys/getters that return `undefined` or throw errors
+ * - Any other custom value that the user has defined
+ *
+ * Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`
+ * checks.
+ */
+declare function getProperties(meta: EntityMetadata): Record<string, any>;
+/**
+ * Returns the `LazyRelation`s (...and transientField) for `meta`.
+ *
+ * Should only be used by `newEntity` while moving relations to the prototype.
+ */
+declare function getLazyFields(meta: EntityMetadata): [string, LazyRelation<any> | object][];
+declare class UnknownProperty {}
+//#endregion
+export { UnknownProperty, getLazyFields, getProperties };
+//# sourceMappingURL=getProperties.d.mts.map

package/build/getProperties.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"getProperties.d.mts","names":[],"sources":["../src/getProperties.ts"],"mappings":";;;;;;;;;;;;;;;;;;;iBAqBgB,cAAc,MAAM,iBAAiB;;;;;;iBAkGrC,cAAc,MAAM,0BAA0B;cAMjD"}

package/build/getProperties.js

@@ -1,141 +1,84 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.UnknownProperty = void 0;
-exports.getProperties = getProperties;
-exports.getLazyFields = getLazyFields;
-const BaseEntity_1 = require("./BaseEntity");
-const newEntity_1 = require("./newEntity");
-const utils_1 = require("./utils");
+import { fail, partition } from "./utils.js";
+import { LazyRelation } from "./newEntity.js";
+import "./EntityMetadata.js";
+import { BaseEntity } from "./BaseEntity.js";
+//#region src/getProperties.ts
 /**
- * Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.
- *
- * This is a little tricky because field assignments don't show up on the prototype, so we actually
- * instantiate a throw-away instance to observe the side-effect of what fields it has.
- *
- * The map values will be:
- *
- * - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations
- * - The primitive value like true/false/"foo" for getters that return primitive values
- * - A `UnknownProperty` for keys/getters that return `undefined` or throw errors
- * - Any other custom value that the user has defined
- *
- * Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`
- * checks.
- */
+* Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.
+*
+* This is a little tricky because field assignments don't show up on the prototype, so we actually
+* instantiate a throw-away instance to observe the side-effect of what fields it has.
+*
+* The map values will be:
+*
+* - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations
+* - The primitive value like true/false/"foo" for getters that return primitive values
+* - A `UnknownProperty` for keys/getters that return `undefined` or throw errors
+* - Any other custom value that the user has defined
+*
+* Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`
+* checks.
+*/
 function getProperties(meta) {
-    // If meta is an STI subtype, give it a different key
-    const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;
-    if (propertiesCache[key]) {
-        return propertiesCache[key];
-    }
-    // Immediately populate key to avoid infinite loops when we later call `instance[key]` to probe
-    // for properties, and we end up calling a getter than invokes a ReactiveField/anything else that
-    // happens to ask for properties.
-    // The caller will admittedly see incorrect (empty) properties, but we generally expect these "evaled
-    // on fake instances" getters to throw nonsense errors anyway (which we suppress), so it should be fine.
-    const cached = (propertiesCache[key] = {});
-    const fakeEm = undefined;
-    const instance = new meta.cstr(fakeEm, true);
-    // Mostly for historical reasons, we don't treat known primitives/enums as properties,
-    // i.e. properties were originally meant to be the wrapper objects like `hasOne`,
-    // `hasMany`, `ReactiveField`, etc.
-    //
-    // That said, we've since start leaking other things like getters, regular async methods,
-    // etc., into properties, so that `entityResolver` can pick them up as keys to put into
-    // the GraphQL resolvers. So we should probably just remove this filter and let everything
-    // get returned as properties.
-    const knownPrimitives = Object.values(meta.allFields)
-        .filter((f) => f.kind === "primaryKey" || f.kind === "primitive" || f.kind === "enum")
-        .map((f) => f.fieldName);
-    // We can look directly at the `instance` to find all relations (`has...` calls), and any other
-    // instance-level fields (of which only the special `transientFields` is expected/allowed).
-    const [relationFields, otherFields] = (0, utils_1.partition)(Object.entries(instance), ([, value]) => value instanceof newEntity_1.LazyField);
-    // Enforce transientFields usage
-    const invalidFields = otherFields.filter(([fieldName]) => fieldName !== "transientFields");
-    if (invalidFields.length > 0) {
-        throw new Error(`${meta.type} has invalid class fields, ${invalidFields.map(([k]) => k).join(", ")} should go in transientFields`);
-    }
-    const properties = [
-        // Include the instance-level relations that will be getter-ized by `newEntity`
-        ...relationFields,
-        // And then any prototype-level getters/methods like `isRed` by recursively looking for ownKeys
-        // (this is the previously-mentioned nod to entityResolver to let it copy over getters/methods).
-        ...getRecursivePrototypeKeys(instance)
-            .filter((key) => !knownPrimitives.includes(key))
-            .map((key) => {
-            try {
-                return [key, instance[key] ?? unknown];
-            }
-            catch {
-                return [key, unknown];
-            }
-        }),
-    ];
-    // Keep one version with the relations still lazy, solely for `newEntity`
-    // (technically newEntity will only ask for this once-per-cstr, so a cache is kind of over-kill,
-    // but creating it here, right before we `relationCstr.create`, is a convenient spot).
-    lazyFields[key] = [...relationFields, ...otherFields];
-    // But expose to everyone else the concrete/constructed relations
-    Object.assign(cached, Object.fromEntries(properties.map(([fieldName, value]) => [
-        fieldName,
-        value instanceof newEntity_1.LazyField ? value.create(instance, fieldName) : value,
-    ])));
-    // Since our fake instance is actually generating the callbacks for our lazy fields, it will be captured in any
-    // lambdas created.  If any of them reference `this`, then they'll actually be referencing the fake instance.  So we
-    // need to clear out any properties directly on the fake instance now that we're done with it and use a proxy to
-    // intercept any attempts to access `this` from within the callbacks and fail.
-    Object.setPrototypeOf(instance, afterGetPropertiesInstancePrototypeProxy);
-    for (const prop of Object.getOwnPropertyNames(instance)) {
-        if (prop !== "__data")
-            delete instance[prop];
-    }
-    return cached;
+	const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;
+	if (propertiesCache[key]) return propertiesCache[key];
+	const cached = propertiesCache[key] = {};
+	const instance = new meta.cstr(void 0, true);
+	const knownPrimitives = Object.values(meta.allFields).filter((f) => f.kind === "primaryKey" || f.kind === "primitive" || f.kind === "enum").map((f) => f.fieldName);
+	const [relationFields, otherFields] = partition(Object.entries(instance), ([, value]) => value instanceof LazyRelation);
+	const invalidFields = otherFields.filter(([fieldName]) => fieldName !== "transientFields");
+	if (invalidFields.length > 0) throw new Error(`${meta.type} has invalid class fields, ${invalidFields.map(([k]) => k).join(", ")} should go in transientFields`);
+	const properties = [...relationFields, ...getRecursivePrototypeKeys(instance).filter((key) => !knownPrimitives.includes(key)).map((key) => {
+		try {
+			return [key, instance[key] ?? unknown];
+		} catch {
+			return [key, unknown];
+		}
+	})];
+	lazyFields[key] = [...relationFields, ...otherFields];
+	Object.assign(cached, Object.fromEntries(properties.map(([fieldName, value]) => [fieldName, value instanceof LazyRelation ? value.create(instance, fieldName) : value])));
+	Object.setPrototypeOf(instance, afterGetPropertiesInstancePrototypeProxy);
+	for (const prop of Object.getOwnPropertyNames(instance)) if (prop !== "__data") delete instance[prop];
+	return cached;
 }
-const afterGetPropertiesInstancePrototypeProxy = new Proxy({}, { get: () => (0, utils_1.fail)("Cannot use 'this' in a property callback") });
+const afterGetPropertiesInstancePrototypeProxy = new Proxy({}, { get: () => fail("Cannot use 'this' in a property callback") });
 /**
- * Returns the `LazyField`s (...and transientField) for `meta`.
- *
- * Should only be used by `newEntity` while moving relations to the prototype.
- */
+* Returns the `LazyRelation`s (...and transientField) for `meta`.
+*
+* Should only be used by `newEntity` while moving relations to the prototype.
+*/
 function getLazyFields(meta) {
-    getProperties(meta); // We populate the lazyFields during getProperties
-    const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;
-    return lazyFields[key];
+	getProperties(meta);
+	const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;
+	return lazyFields[key];
 }
-class UnknownProperty {
-}
-exports.UnknownProperty = UnknownProperty;
+var UnknownProperty = class {};
 const unknown = new UnknownProperty();
 const propertiesCache = {};
 const lazyFields = {};
-// These are keys we codegen into `AuthorCodegen` files to get the best typing
-// experience, but really should be treated as BaseEntity keys that we don't
-// need to expose from `getProperties`.
-const ignoredKeys = new Set([
-    "constructor",
-    "id",
-    "idMaybe",
-    "idTagged",
-    "idTaggedMaybe",
-    "set",
-    "setPartial",
-    "setDeepPartial",
-    "changes",
-    "isSoftDeletedEntity",
-    "load",
-    "populate",
-    "isLoaded",
-    "toJSON",
+const ignoredKeys = /* @__PURE__ */ new Set([
+	"constructor",
+	"id",
+	"idMaybe",
+	"idTagged",
+	"idTaggedMaybe",
+	"set",
+	"setPartial",
+	"setDeepPartial",
+	"changes",
+	"isSoftDeletedEntity",
+	"softDelete",
+	"load",
+	"populate",
+	"isLoaded",
+	"toJSON"
 ]);
 function getRecursivePrototypeKeys(instance) {
-    const keys = [];
-    for (let curr = Object.getPrototypeOf(instance); curr && curr !== BaseEntity_1.BaseEntity.prototype; curr = Object.getPrototypeOf(curr)) {
-        for (const name of Object.getOwnPropertyNames(curr)) {
-            if (!ignoredKeys.has(name)) {
-                keys.push(name);
-            }
-        }
-    }
-    return keys;
+	const keys = [];
+	for (let curr = Object.getPrototypeOf(instance); curr && curr !== BaseEntity.prototype; curr = Object.getPrototypeOf(curr)) for (const name of Object.getOwnPropertyNames(curr)) if (!ignoredKeys.has(name)) keys.push(name);
+	return keys;
 }
+//#endregion
+export { UnknownProperty, getLazyFields, getProperties };
+
 //# sourceMappingURL=getProperties.js.map

package/build/getProperties.js.map

@@ -1 +1 @@
-{"version":3,"file":"getProperties.js","sourceRoot":"","sources":["../src/getProperties.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"getProperties.js","names":[],"sources":["../src/getProperties.ts"],"sourcesContent":["import { BaseEntity } from \"src/BaseEntity.ts\";\nimport { type EntityMetadata } from \"src/EntityMetadata.ts\";\nimport { LazyRelation } from \"src/newEntity.ts\";\nimport { fail, partition } from \"src/utils.ts\";\n\n/**\n * Returns the relations in `meta`, both those defined in the codegen file + any user-defined `CustomReference`s.\n *\n * This is a little tricky because field assignments don't show up on the prototype, so we actually\n * instantiate a throw-away instance to observe the side-effect of what fields it has.\n *\n * The map values will be:\n *\n * - The `AbstractRelationImpl` or `AbstractPropertyImpl` for relations\n * - The primitive value like true/false/\"foo\" for getters that return primitive values\n * - A `UnknownProperty` for keys/getters that return `undefined` or throw errors\n * - Any other custom value that the user has defined\n *\n * Basically the values won't be `undefined`, to avoid throwing off `if getPropertyes(meta)[key]`\n * checks.\n */\nexport function getProperties(meta: EntityMetadata): Record<string, any> {\n  // If meta is an STI subtype, give it a different key\n  const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;\n  if (propertiesCache[key]) {\n    return propertiesCache[key];\n  }\n\n  // Immediately populate key to avoid infinite loops when we later call `instance[key]` to probe\n  // for properties, and we end up calling a getter than invokes a ReactiveField/anything else that\n  // happens to ask for properties.\n  // The caller will admittedly see incorrect (empty) properties, but we generally expect these \"evaled\n  // on fake instances\" getters to throw nonsense errors anyway (which we suppress), so it should be fine.\n  const cached = (propertiesCache[key] = {});\n\n  const fakeEm = undefined as any;\n  const instance = new (meta.cstr as any)(fakeEm, true);\n\n  // Mostly for historical reasons, we don't treat known primitives/enums as properties,\n  // i.e. properties were originally meant to be the wrapper objects like `hasOne`,\n  // `hasMany`, `ReactiveField`, etc.\n  //\n  // That said, we've since start leaking other things like getters, regular async methods,\n  // etc., into properties, so that `entityResolver` can pick them up as keys to put into\n  // the GraphQL resolvers. So we should probably just remove this filter and let everything\n  // get returned as properties.\n  const knownPrimitives = Object.values(meta.allFields)\n    .filter((f) => f.kind === \"primaryKey\" || f.kind === \"primitive\" || f.kind === \"enum\")\n    .map((f) => f.fieldName);\n\n  // We can look directly at the `instance` to find all relations (`has...` calls), and any other\n  // instance-level fields (of which only the special `transientFields` is expected/allowed).\n  const [relationFields, otherFields] = partition(\n    Object.entries(instance),\n    ([, value]) => value instanceof LazyRelation,\n  );\n\n  // Enforce transientFields usage\n  const invalidFields = otherFields.filter(([fieldName]) => fieldName !== \"transientFields\");\n  if (invalidFields.length > 0) {\n    throw new Error(\n      `${meta.type} has invalid class fields, ${invalidFields.map(([k]) => k).join(\", \")} should go in transientFields`,\n    );\n  }\n\n  const properties = [\n    // Include the instance-level relations that will be getter-ized by `newEntity`\n    ...relationFields,\n    // And then any prototype-level getters/methods like `isRed` by recursively looking for ownKeys\n    // (this is the previously-mentioned nod to entityResolver to let it copy over getters/methods).\n    ...getRecursivePrototypeKeys(instance)\n      .filter((key) => !knownPrimitives.includes(key))\n      .map((key) => {\n        try {\n          return [key, (instance as any)[key] ?? unknown];\n        } catch {\n          return [key, unknown];\n        }\n      }),\n  ];\n\n  // Keep one version with the relations still lazy, solely for `newEntity`\n  // (technically newEntity will only ask for this once-per-cstr, so a cache is kind of over-kill,\n  // but creating it here, right before we `relationCstr.create`, is a convenient spot).\n  lazyFields[key] = [...relationFields, ...otherFields];\n\n  // But expose to everyone else the concrete/constructed relations\n  Object.assign(\n    cached,\n    Object.fromEntries(\n      properties.map(([fieldName, value]) => [\n        fieldName,\n        value instanceof LazyRelation ? value.create(instance, fieldName) : value,\n      ]),\n    ),\n  );\n\n  // Since our fake instance is actually generating the callbacks for our lazy fields, it will be captured in any\n  // lambdas created.  If any of them reference `this`, then they'll actually be referencing the fake instance.  So we\n  // need to clear out any properties directly on the fake instance now that we're done with it and use a proxy to\n  // intercept any attempts to access `this` from within the callbacks and fail.\n  Object.setPrototypeOf(instance, afterGetPropertiesInstancePrototypeProxy);\n  for (const prop of Object.getOwnPropertyNames(instance)) {\n    if (prop !== \"__data\") delete instance[prop];\n  }\n\n  return cached;\n}\n\nconst afterGetPropertiesInstancePrototypeProxy = new Proxy(\n  {},\n  { get: () => fail(\"Cannot use 'this' in a property callback\") },\n);\n\n/**\n * Returns the `LazyRelation`s (...and transientField) for `meta`.\n *\n * Should only be used by `newEntity` while moving relations to the prototype.\n */\nexport function getLazyFields(meta: EntityMetadata): [string, LazyRelation<any> | object][] {\n  getProperties(meta); // We populate the lazyFields during getProperties\n  const key = meta.stiDiscriminatorValue ? `${meta.tableName}:${meta.stiDiscriminatorValue}` : meta.tableName;\n  return lazyFields[key];\n}\n\nexport class UnknownProperty {}\nconst unknown = new UnknownProperty();\n\nconst propertiesCache: Record<string, any> = {};\nconst lazyFields: Record<string, any> = {};\n\n// These are keys we codegen into `AuthorCodegen` files to get the best typing\n// experience, but really should be treated as BaseEntity keys that we don't\n// need to expose from `getProperties`.\nconst ignoredKeys = new Set([\n  \"constructor\",\n  \"id\",\n  \"idMaybe\",\n  \"idTagged\",\n  \"idTaggedMaybe\",\n  \"set\",\n  \"setPartial\",\n  \"setDeepPartial\",\n  \"changes\",\n  \"isSoftDeletedEntity\",\n  \"softDelete\",\n  \"load\",\n  \"populate\",\n  \"isLoaded\",\n  \"toJSON\",\n]);\n\nfunction getRecursivePrototypeKeys(instance: any): string[] {\n  const keys: string[] = [];\n  for (\n    let curr = Object.getPrototypeOf(instance);\n    curr && curr !== BaseEntity.prototype;\n    curr = Object.getPrototypeOf(curr)\n  ) {\n    for (const name of Object.getOwnPropertyNames(curr)) {\n      if (!ignoredKeys.has(name)) {\n        keys.push(name);\n      }\n    }\n  }\n  return keys;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AAqBA,SAAgB,cAAc,MAA2C;CAEvE,MAAM,MAAM,KAAK,wBAAwB,GAAG,KAAK,UAAU,GAAG,KAAK,0BAA0B,KAAK;CAClG,IAAI,gBAAgB,MAClB,OAAO,gBAAgB;CAQzB,MAAM,SAAU,gBAAgB,OAAO,CAAC;CAGxC,MAAM,WAAW,IAAK,KAAK,KAAa,KAAA,GAAQ,IAAI;CAUpD,MAAM,kBAAkB,OAAO,OAAO,KAAK,SAAS,CAAC,CAClD,QAAQ,MAAM,EAAE,SAAS,gBAAgB,EAAE,SAAS,eAAe,EAAE,SAAS,MAAM,CAAC,CACrF,KAAK,MAAM,EAAE,SAAS;CAIzB,MAAM,CAAC,gBAAgB,eAAe,UACpC,OAAO,QAAQ,QAAQ,IACtB,GAAG,WAAW,iBAAiB,YAClC;CAGA,MAAM,gBAAgB,YAAY,QAAQ,CAAC,eAAe,cAAc,iBAAiB;CACzF,IAAI,cAAc,SAAS,GACzB,MAAM,IAAI,MACR,GAAG,KAAK,KAAK,6BAA6B,cAAc,KAAK,CAAC,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,EAAE,8BACrF;CAGF,MAAM,aAAa,CAEjB,GAAG,gBAGH,GAAG,0BAA0B,QAAQ,CAAC,CACnC,QAAQ,QAAQ,CAAC,gBAAgB,SAAS,GAAG,CAAC,CAAC,CAC/C,KAAK,QAAQ;EACZ,IAAI;GACF,OAAO,CAAC,KAAM,SAAiB,QAAQ,OAAO;EAChD,QAAQ;GACN,OAAO,CAAC,KAAK,OAAO;EACtB;CACF,CAAC,CACL;CAKA,WAAW,OAAO,CAAC,GAAG,gBAAgB,GAAG,WAAW;CAGpD,OAAO,OACL,QACA,OAAO,YACL,WAAW,KAAK,CAAC,WAAW,WAAW,CACrC,WACA,iBAAiB,eAAe,MAAM,OAAO,UAAU,SAAS,IAAI,KACtE,CAAC,CACH,CACF;CAMA,OAAO,eAAe,UAAU,wCAAwC;CACxE,KAAK,MAAM,QAAQ,OAAO,oBAAoB,QAAQ,GACpD,IAAI,SAAS,UAAU,OAAO,SAAS;CAGzC,OAAO;AACT;AAEA,MAAM,2CAA2C,IAAI,MACnD,CAAC,GACD,EAAE,WAAW,KAAK,0CAA0C,EAAE,CAChE;;;;;;AAOA,SAAgB,cAAc,MAA8D;CAC1F,cAAc,IAAI;CAClB,MAAM,MAAM,KAAK,wBAAwB,GAAG,KAAK,UAAU,GAAG,KAAK,0BAA0B,KAAK;CAClG,OAAO,WAAW;AACpB;AAEA,IAAa,kBAAb,MAA6B,CAAC;AAC9B,MAAM,UAAU,IAAI,gBAAgB;AAEpC,MAAM,kBAAuC,CAAC;AAC9C,MAAM,aAAkC,CAAC;AAKzC,MAAM,8BAAc,IAAI,IAAI;CAC1B;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;AACF,CAAC;AAED,SAAS,0BAA0B,UAAyB;CAC1D,MAAM,OAAiB,CAAC;CACxB,KACE,IAAI,OAAO,OAAO,eAAe,QAAQ,GACzC,QAAQ,SAAS,WAAW,WAC5B,OAAO,OAAO,eAAe,IAAI,GAEjC,KAAK,MAAM,QAAQ,OAAO,oBAAoB,IAAI,GAChD,IAAI,CAAC,YAAY,IAAI,IAAI,GACvB,KAAK,KAAK,IAAI;CAIpB,OAAO;AACT"}