@tstdl/base 0.86.0-beta2 → 0.86.0-beta3

package/schema/utils/schema.js

@@ -1,139 +1,161 @@
-import { reflectionRegistry } from '../../reflection/registry.js';
-import { toArray } from '../../utils/array/array.js';
-import { memoizeSingle } from '../../utils/function/memoize.js';
-import { mapObjectValues } from '../../utils/object/object.js';
-import { isArray, isDefined, isFunction, isNotNull, isNull, isUndefined } from '../../utils/type-guards.js';
-import { assign } from '../schemas/assign.js';
-import { isObjectSchema, isTypeSchema, isValueSchema, objectSchema, resolveValueType, schemaTestableToSchema, schemaTestablesToSchemas, valueSchema } from '../types/index.js';
-export const normalizeSchema = memoizeSingle(_normalizeSchema, { weak: true });
-export const normalizeObjectSchema = memoizeSingle(_normalizeObjectSchema, { weak: true });
-export const normalizeValueSchema = memoizeSingle(_normalizeValueSchema, { weak: true });
-export const normalizeTypeSchema = memoizeSingle(_normalizeTypeSchema, { weak: true });
-export const getArrayItemSchema = memoizeSingle(_getArrayItemSchema, { weak: true });
-export const tryGetObjectSchemaFromReflection = memoizeSingle(_tryGetObjectSchemaFromReflection, { weak: true });
-export function getObjectSchema(schemaOrType) {
-    return isFunction(schemaOrType)
-        ? getObjectSchemaFromReflection(schemaOrType)
-        : schemaOrType;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var schema_exports = {};
+__export(schema_exports, {
+  getArrayItemSchema: () => getArrayItemSchema,
+  getObjectSchema: () => getObjectSchema,
+  getObjectSchemaFromReflection: () => getObjectSchemaFromReflection,
+  normalizeObjectSchema: () => normalizeObjectSchema,
+  normalizeSchema: () => normalizeSchema,
+  normalizeTypeSchema: () => normalizeTypeSchema,
+  normalizeValueSchema: () => normalizeValueSchema,
+  tryGetObjectSchemaFromReflection: () => tryGetObjectSchemaFromReflection
+});
+module.exports = __toCommonJS(schema_exports);
+var import_registry = require("../../reflection/registry.js");
+var import_array = require("../../utils/array/array.js");
+var import_memoize = require("../../utils/function/memoize.js");
+var import_object = require("../../utils/object/object.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_assign = require("../schemas/assign.js");
+var import_types = require("../types/index.js");
+const normalizeSchema = (0, import_memoize.memoizeSingle)(_normalizeSchema, { weak: true });
+const normalizeObjectSchema = (0, import_memoize.memoizeSingle)(_normalizeObjectSchema, { weak: true });
+const normalizeValueSchema = (0, import_memoize.memoizeSingle)(_normalizeValueSchema, { weak: true });
+const normalizeTypeSchema = (0, import_memoize.memoizeSingle)(_normalizeTypeSchema, { weak: true });
+const getArrayItemSchema = (0, import_memoize.memoizeSingle)(_getArrayItemSchema, { weak: true });
+const tryGetObjectSchemaFromReflection = (0, import_memoize.memoizeSingle)(_tryGetObjectSchemaFromReflection, { weak: true });
+function getObjectSchema(schemaOrType) {
+  return (0, import_type_guards.isFunction)(schemaOrType) ? getObjectSchemaFromReflection(schemaOrType) : schemaOrType;
 }
 function _normalizeSchema(schema) {
-    if (isObjectSchema(schema)) {
-        return normalizeObjectSchema(schema);
-    }
-    if (isValueSchema(schema)) {
-        return normalizeValueSchema(schema);
-    }
-    if (isTypeSchema(schema)) {
-        return normalizeTypeSchema(schema);
-    }
-    throw new Error('Unsupported schema.');
+  if ((0, import_types.isObjectSchema)(schema)) {
+    return normalizeObjectSchema(schema);
+  }
+  if ((0, import_types.isValueSchema)(schema)) {
+    return normalizeValueSchema(schema);
+  }
+  if ((0, import_types.isTypeSchema)(schema)) {
+    return normalizeTypeSchema(schema);
+  }
+  throw new Error("Unsupported schema.");
 }
 function _normalizeObjectSchema(schema) {
-    const unknownPropertiesSchema = (isDefined(schema.unknownProperties) && (!isArray(schema.unknownProperties) || (schema.unknownProperties.length > 0))) ? schemaTestablesToSchemas(schema.unknownProperties) : undefined;
-    const unknownPropertiesKeySchema = (isDefined(schema.unknownPropertiesKey) && (!isArray(schema.unknownPropertiesKey) || (schema.unknownPropertiesKey.length > 0))) ? schemaTestablesToSchemas(schema.unknownPropertiesKey) : undefined;
-    const allowUnknownProperties = ((isArray(unknownPropertiesSchema) && (unknownPropertiesSchema.length > 0)) || isDefined(unknownPropertiesSchema));
-    const normalizedSchema = {
-        factory: schema.factory,
-        properties: mapObjectValues(schema.properties, (propertyValueType) => schemaTestablesToSchemas(propertyValueType)),
-        mask: schema.mask,
-        allowUnknownProperties,
-        unknownProperties: isArray(unknownPropertiesSchema) ? valueSchema(unknownPropertiesSchema) : unknownPropertiesSchema,
-        unknownPropertiesKey: isArray(unknownPropertiesKeySchema) ? valueSchema(unknownPropertiesKeySchema) : unknownPropertiesKeySchema
-    };
-    return normalizedSchema;
+  const unknownPropertiesSchema = (0, import_type_guards.isDefined)(schema.unknownProperties) && (!(0, import_type_guards.isArray)(schema.unknownProperties) || schema.unknownProperties.length > 0) ? (0, import_types.schemaTestablesToSchemas)(schema.unknownProperties) : void 0;
+  const unknownPropertiesKeySchema = (0, import_type_guards.isDefined)(schema.unknownPropertiesKey) && (!(0, import_type_guards.isArray)(schema.unknownPropertiesKey) || schema.unknownPropertiesKey.length > 0) ? (0, import_types.schemaTestablesToSchemas)(schema.unknownPropertiesKey) : void 0;
+  const allowUnknownProperties = (0, import_type_guards.isArray)(unknownPropertiesSchema) && unknownPropertiesSchema.length > 0 || (0, import_type_guards.isDefined)(unknownPropertiesSchema);
+  const normalizedSchema = {
+    factory: schema.factory,
+    properties: (0, import_object.mapObjectValues)(schema.properties, (propertyValueType) => (0, import_types.schemaTestablesToSchemas)(propertyValueType)),
+    mask: schema.mask,
+    allowUnknownProperties,
+    unknownProperties: (0, import_type_guards.isArray)(unknownPropertiesSchema) ? (0, import_types.valueSchema)(unknownPropertiesSchema) : unknownPropertiesSchema,
+    unknownPropertiesKey: (0, import_type_guards.isArray)(unknownPropertiesKeySchema) ? (0, import_types.valueSchema)(unknownPropertiesKeySchema) : unknownPropertiesKeySchema
+  };
+  return normalizedSchema;
 }
 function _normalizeValueSchema(schema) {
-    const normalizedValueSchema = {
-        schema: [...new Set(toArray(schema.schema))].map(schemaTestableToSchema),
-        array: schema.array ?? false,
-        optional: schema.optional ?? false,
-        nullable: schema.nullable ?? false,
-        coerce: schema.coerce ?? false,
-        coercers: new Map(),
-        transformers: toArray(schema.transformers ?? []),
-        arrayConstraints: toArray(schema.arrayConstraints ?? []),
-        valueConstraints: toArray(schema.valueConstraints ?? [])
-    };
-    for (const coercer of toArray(schema.coercers ?? [])) {
-        for (const sourceType of toArray(coercer.sourceType)) {
-            if (!normalizedValueSchema.coercers.has(sourceType)) {
-                normalizedValueSchema.coercers.set(sourceType, []);
-            }
-            normalizedValueSchema.coercers.get(sourceType).push(coercer);
-        }
+  const normalizedValueSchema = {
+    schema: [...new Set((0, import_array.toArray)(schema.schema))].map(import_types.schemaTestableToSchema),
+    array: schema.array ?? false,
+    optional: schema.optional ?? false,
+    nullable: schema.nullable ?? false,
+    coerce: schema.coerce ?? false,
+    coercers: /* @__PURE__ */ new Map(),
+    transformers: (0, import_array.toArray)(schema.transformers ?? []),
+    arrayConstraints: (0, import_array.toArray)(schema.arrayConstraints ?? []),
+    valueConstraints: (0, import_array.toArray)(schema.valueConstraints ?? [])
+  };
+  for (const coercer of (0, import_array.toArray)(schema.coercers ?? [])) {
+    for (const sourceType of (0, import_array.toArray)(coercer.sourceType)) {
+      if (!normalizedValueSchema.coercers.has(sourceType)) {
+        normalizedValueSchema.coercers.set(sourceType, []);
+      }
+      normalizedValueSchema.coercers.get(sourceType).push(coercer);
     }
-    return normalizedValueSchema;
+  }
+  return normalizedValueSchema;
 }
 function _normalizeTypeSchema(schema) {
-    const normalizedSchema = {
-        foo: resolveValueType(schema.type)
-    };
-    return normalizedSchema;
+  const normalizedSchema = {
+    foo: (0, import_types.resolveValueType)(schema.type)
+  };
+  return normalizedSchema;
 }
 function _getArrayItemSchema(schema) {
-    const itemSchema = {
-        schema: schema.schema,
-        transformers: schema.transformers,
-        valueConstraints: schema.valueConstraints
-    };
-    return itemSchema;
+  const itemSchema = {
+    schema: schema.schema,
+    transformers: schema.transformers,
+    valueConstraints: schema.valueConstraints
+  };
+  return itemSchema;
 }
-export function getObjectSchemaFromReflection(type) {
-    const schema = tryGetObjectSchemaFromReflection(type);
-    if (isNull(schema)) {
-        throw new Error(`Could not get schema for ${type.name} from reflection data.`);
-    }
-    return schema;
+function getObjectSchemaFromReflection(type) {
+  const schema = tryGetObjectSchemaFromReflection(type);
+  if ((0, import_type_guards.isNull)(schema)) {
+    throw new Error(`Could not get schema for ${type.name} from reflection data.`);
+  }
+  return schema;
 }
 function _tryGetObjectSchemaFromReflection(type) {
-    const metadata = reflectionRegistry.getMetadata(type);
-    if (isUndefined(metadata)) {
-        return null;
+  const metadata = import_registry.reflectionRegistry.getMetadata(type);
+  if ((0, import_type_guards.isUndefined)(metadata)) {
+    return null;
+  }
+  const typeData = metadata.data.tryGet("schema") ?? {};
+  const dataSchema = (0, import_types.isTypeSchema)(typeData.schema) ? getObjectSchema(typeData.schema.type) : (0, import_types.isObjectSchema)(typeData.schema) ? typeData.schema : (0, import_type_guards.isFunction)(typeData.schema) ? getObjectSchema(typeData.schema) : void 0;
+  const schema = (0, import_types.objectSchema)({
+    sourceType: type,
+    factory: (0, import_type_guards.isDefined)(typeData.factory) ? { builder: typeData.factory } : { type },
+    properties: dataSchema?.properties ?? getObjectSchemaPropertiesFromReflection(metadata, type),
+    mask: typeData.mask ?? dataSchema?.mask,
+    unknownProperties: ((0, import_type_guards.isUndefined)(typeData.unknownProperties) || (0, import_type_guards.isArray)(typeData.unknownProperties) && typeData.unknownProperties.length == 0 ? void 0 : typeData.unknownProperties) ?? dataSchema?.unknownProperties,
+    unknownPropertiesKey: ((0, import_type_guards.isUndefined)(typeData.unknownPropertiesKey) || (0, import_type_guards.isArray)(typeData.unknownPropertiesKey) && typeData.unknownPropertiesKey.length == 0 ? void 0 : typeData.unknownPropertiesKey) ?? dataSchema?.unknownPropertiesKey
+  });
+  if ((0, import_type_guards.isUndefined)(dataSchema)) {
+    const prototype = Reflect.getPrototypeOf(type);
+    if ((0, import_type_guards.isNotNull)(prototype) && import_registry.reflectionRegistry.hasType(prototype)) {
+      const parentSchema = getObjectSchemaFromReflection(prototype);
+      return (0, import_assign.assign)(parentSchema, schema);
     }
-    const typeData = metadata.data.tryGet('schema') ?? {};
-    const dataSchema = isTypeSchema(typeData.schema)
-        ? getObjectSchema(typeData.schema.type)
-        : isObjectSchema(typeData.schema)
-            ? typeData.schema
-            : isFunction(typeData.schema)
-                ? getObjectSchema(typeData.schema)
-                : undefined;
-    const schema = objectSchema({
-        sourceType: type,
-        factory: isDefined(typeData.factory) ? { builder: typeData.factory } : { type: type },
-        properties: dataSchema?.properties ?? getObjectSchemaPropertiesFromReflection(metadata, type),
-        mask: typeData.mask ?? dataSchema?.mask,
-        unknownProperties: ((isUndefined(typeData.unknownProperties) || (isArray(typeData.unknownProperties) && (typeData.unknownProperties.length == 0))) ? undefined : typeData.unknownProperties) ?? dataSchema?.unknownProperties,
-        unknownPropertiesKey: ((isUndefined(typeData.unknownPropertiesKey) || (isArray(typeData.unknownPropertiesKey) && (typeData.unknownPropertiesKey.length == 0))) ? undefined : typeData.unknownPropertiesKey) ?? dataSchema?.unknownPropertiesKey
-    });
-    if (isUndefined(dataSchema)) {
-        const prototype = Reflect.getPrototypeOf(type);
-        if (isNotNull(prototype) && reflectionRegistry.hasType(prototype)) {
-            const parentSchema = getObjectSchemaFromReflection(prototype);
-            return assign(parentSchema, schema);
-        }
-    }
-    return schema;
+  }
+  return schema;
 }
 function getObjectSchemaPropertiesFromReflection(metadata, type) {
-    const properties = {};
-    for (const [key, propertyMetadata] of metadata.properties) {
-        const reflectionData = propertyMetadata.data.tryGet('schema');
-        const itemType = reflectionData?.schema;
-        const array = (reflectionData?.array == true) ? true : undefined;
-        if (array && (isUndefined(itemType) || (isArray(itemType) && (itemType.length == 0)))) {
-            throw new Error(`Item type missing on type ${type.name} at property "${String(key)}"`);
-        }
-        properties[key] = valueSchema(schemaTestablesToSchemas(itemType ?? propertyMetadata.type), {
-            array,
-            optional: reflectionData?.optional,
-            nullable: reflectionData?.nullable,
-            coerce: reflectionData?.coerce,
-            coercers: reflectionData?.coercers,
-            transformers: reflectionData?.transformers,
-            arrayConstraints: reflectionData?.arrayConstraints,
-            valueConstraints: reflectionData?.valueConstraints
-        });
+  const properties = {};
+  for (const [key, propertyMetadata] of metadata.properties) {
+    const reflectionData = propertyMetadata.data.tryGet("schema");
+    const itemType = reflectionData?.schema;
+    const array = reflectionData?.array == true ? true : void 0;
+    if (array && ((0, import_type_guards.isUndefined)(itemType) || (0, import_type_guards.isArray)(itemType) && itemType.length == 0)) {
+      throw new Error(`Item type missing on type ${type.name} at property "${String(key)}"`);
     }
-    return properties;
+    properties[key] = (0, import_types.valueSchema)((0, import_types.schemaTestablesToSchemas)(itemType ?? propertyMetadata.type), {
+      array,
+      optional: reflectionData?.optional,
+      nullable: reflectionData?.nullable,
+      coerce: reflectionData?.coerce,
+      coercers: reflectionData?.coercers,
+      transformers: reflectionData?.transformers,
+      arrayConstraints: reflectionData?.arrayConstraints,
+      valueConstraints: reflectionData?.valueConstraints
+    });
+  }
+  return properties;
 }

package/schema/utils/value-type.js

@@ -1,56 +1,79 @@
-import { toArray } from '../../utils/array/array.js';
-import { isArray, isFunction, isNull, isString, isUndefined } from '../../utils/type-guards.js';
-import { isDeferredValueType, isObjectSchema, isTypeSchema, isValueSchema, primitiveConstructorSet, resolveValueType, resolveValueTypes } from '../types/types.js';
-const lowercaseTypesSet = new Set([...primitiveConstructorSet, Object, Array]);
-export function getValueType(value) {
-    if (isUndefined(value)) {
-        return 'undefined';
-    }
-    if (isNull(value)) {
-        return 'null';
-    }
-    return value.constructor;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var value_type_exports = {};
+__export(value_type_exports, {
+  getSchemaTypeNames: () => getSchemaTypeNames,
+  getSchemaValueTypes: () => getSchemaValueTypes,
+  getValueType: () => getValueType,
+  getValueTypeName: () => getValueTypeName,
+  includesValueType: () => includesValueType
+});
+module.exports = __toCommonJS(value_type_exports);
+var import_array = require("../../utils/array/array.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var import_types = require("../types/types.js");
+const lowercaseTypesSet = /* @__PURE__ */ new Set([...import_types.primitiveConstructorSet, Object, Array]);
+function getValueType(value) {
+  if ((0, import_type_guards.isUndefined)(value)) {
+    return "undefined";
+  }
+  if ((0, import_type_guards.isNull)(value)) {
+    return "null";
+  }
+  return value.constructor;
 }
-export function includesValueType(valueType, valueTypes) {
-    const resolvedValueTypes = resolveValueTypes(valueTypes);
-    const resolvedValueType = resolveValueType(valueType);
-    if (isArray(resolvedValueTypes)) {
-        return resolvedValueTypes.includes(resolvedValueType);
-    }
-    return resolvedValueType == resolvedValueTypes;
+function includesValueType(valueType, valueTypes) {
+  const resolvedValueTypes = (0, import_types.resolveValueTypes)(valueTypes);
+  const resolvedValueType = (0, import_types.resolveValueType)(valueType);
+  if ((0, import_type_guards.isArray)(resolvedValueTypes)) {
+    return resolvedValueTypes.includes(resolvedValueType);
+  }
+  return resolvedValueType == resolvedValueTypes;
 }
-export function getValueTypeName(valueType) {
-    const resolvedValueType = resolveValueType(valueType);
-    return isString(resolvedValueType)
-        ? resolvedValueType
-        : lowercaseTypesSet.has(resolvedValueType)
-            ? resolvedValueType.name.toLowerCase()
-            : resolvedValueType.name;
+function getValueTypeName(valueType) {
+  const resolvedValueType = (0, import_types.resolveValueType)(valueType);
+  return (0, import_type_guards.isString)(resolvedValueType) ? resolvedValueType : lowercaseTypesSet.has(resolvedValueType) ? resolvedValueType.name.toLowerCase() : resolvedValueType.name;
 }
-export function getSchemaTypeNames(schema) {
-    return getSchemaValueTypes(schema).map(getValueTypeName);
+function getSchemaTypeNames(schema) {
+  return getSchemaValueTypes(schema).map(getValueTypeName);
 }
-export function getSchemaValueTypes(schema) {
-    if (isTypeSchema(schema)) {
-        return [resolveValueType(schema.type)];
-    }
-    if (isFunction(schema)) {
-        return [schema];
-    }
-    if (isString(schema)) {
-        return [schema];
-    }
-    if (isObjectSchema(schema)) {
-        return [resolveValueType(schema.sourceType ?? Object)];
-    }
-    if (isValueSchema(schema)) {
-        return [...new Set(toArray(schema.schema).flatMap(getSchemaValueTypes))];
-    }
-    if (isDeferredValueType(schema)) {
-        return getSchemaValueTypes(resolveValueType(schema));
-    }
-    if (isArray(schema)) {
-        return schema.flatMap(getSchemaValueTypes);
-    }
-    throw new Error('Unsupported schema');
+function getSchemaValueTypes(schema) {
+  if ((0, import_types.isTypeSchema)(schema)) {
+    return [(0, import_types.resolveValueType)(schema.type)];
+  }
+  if ((0, import_type_guards.isFunction)(schema)) {
+    return [schema];
+  }
+  if ((0, import_type_guards.isString)(schema)) {
+    return [schema];
+  }
+  if ((0, import_types.isObjectSchema)(schema)) {
+    return [(0, import_types.resolveValueType)(schema.sourceType ?? Object)];
+  }
+  if ((0, import_types.isValueSchema)(schema)) {
+    return [...new Set((0, import_array.toArray)(schema.schema).flatMap(getSchemaValueTypes))];
+  }
+  if ((0, import_types.isDeferredValueType)(schema)) {
+    return getSchemaValueTypes((0, import_types.resolveValueType)(schema));
+  }
+  if ((0, import_type_guards.isArray)(schema)) {
+    return schema.flatMap(getSchemaValueTypes);
+  }
+  throw new Error("Unsupported schema");
 }

package/search-index/elastic/config.d.ts

@@ -1,8 +1,8 @@
-import type { Injectable } from '../../container/index.js';
-import { type resolveArgumentType } from '../../container/index.js';
 import type { Entity } from '../../database/index.js';
+import { resolveArgumentType } from '../../injector/interfaces.js';
+import type { Resolvable } from '../../injector/interfaces.js';
 export type ElasticSearchIndexConfigArgument<T extends Entity = Entity> = string | ElasticSearchIndexConfig<T>;
-export declare abstract class ElasticSearchIndexConfig<T extends Entity = Entity> implements Injectable<ElasticSearchIndexConfigArgument> {
+export declare abstract class ElasticSearchIndexConfig<T extends Entity = Entity> implements Resolvable<ElasticSearchIndexConfigArgument> {
     readonly indexName: string;
     readonly [resolveArgumentType]: ElasticSearchIndexConfigArgument<T>;
     constructor(indexNameOrConfig: string | ElasticSearchIndexConfig<T>);

package/search-index/elastic/config.js

@@ -1,25 +1,56 @@
-var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
-    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
-    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
-    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
-    return c > 3 && r && Object.defineProperty(target, key, r), r;
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __metadata = (this && this.__metadata) || function (k, v) {
-    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-var __param = (this && this.__param) || function (paramIndex, decorator) {
-    return function (target, key) { decorator(target, key, paramIndex); }
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var config_exports = {};
+__export(config_exports, {
+  ElasticSearchIndexConfig: () => ElasticSearchIndexConfig
+});
+module.exports = __toCommonJS(config_exports);
+var import_decorators = require("../../injector/decorators.js");
+var import_interfaces = require("../../injector/interfaces.js");
+var import_type_guards = require("../../utils/type-guards.js");
+var __decorate = function(decorators, target, key, desc) {
+  var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+  if (typeof Reflect === "object" && typeof Reflect.decorate === "function")
+    r = Reflect.decorate(decorators, target, key, desc);
+  else
+    for (var i = decorators.length - 1; i >= 0; i--)
+      if (d = decorators[i])
+        r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+  return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { injectable, injectArg } from '../../container/index.js';
-import { isString } from '../../utils/type-guards.js';
-export let ElasticSearchIndexConfig = class ElasticSearchIndexConfig {
-    indexName;
-    constructor(indexNameOrConfig) {
-        this.indexName = isString(indexNameOrConfig) ? indexNameOrConfig : indexNameOrConfig.indexName;
-    }
+var __metadata = function(k, v) {
+  if (typeof Reflect === "object" && typeof Reflect.metadata === "function")
+    return Reflect.metadata(k, v);
+};
+var __param = function(paramIndex, decorator) {
+  return function(target, key) {
+    decorator(target, key, paramIndex);
+  };
+};
+let ElasticSearchIndexConfig = class ElasticSearchIndexConfig2 {
+  indexName;
+  constructor(indexNameOrConfig) {
+    this.indexName = (0, import_type_guards.isString)(indexNameOrConfig) ? indexNameOrConfig : indexNameOrConfig.indexName;
+  }
 };
 ElasticSearchIndexConfig = __decorate([
-    injectable(),
-    __param(0, injectArg()),
-    __metadata("design:paramtypes", [Object])
+  (0, import_decorators.Injectable)(),
+  __param(0, (0, import_decorators.InjectArg)()),
+  __metadata("design:paramtypes", [Object])
 ], ElasticSearchIndexConfig);

package/search-index/elastic/index.js

@@ -1,6 +1,23 @@
-export * from './config.js';
-export * from './keyword-rewriter.js';
-export * from './model/index.js';
-export * from './module.js';
-export * from './search-index.js';
-export * from './types.js';
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elastic_exports = {};
+module.exports = __toCommonJS(elastic_exports);
+__reExport(elastic_exports, require("./config.js"), module.exports);
+__reExport(elastic_exports, require("./keyword-rewriter.js"), module.exports);
+__reExport(elastic_exports, require("./model/index.js"), module.exports);
+__reExport(elastic_exports, require("./module.js"), module.exports);
+__reExport(elastic_exports, require("./search-index.js"), module.exports);
+__reExport(elastic_exports, require("./types.js"), module.exports);

package/search-index/elastic/keyword-rewriter.js

@@ -1,18 +1,41 @@
-export class KeywordRewriter {
-    fields;
-    constructor(fields) {
-        this.fields = new Set(fields);
-    }
-    add(field) {
-        this.fields.add(field);
-    }
-    remove(field) {
-        this.fields.delete(field);
-    }
-    requiresRewrite(field) {
-        return this.fields.has(field);
-    }
-    rewriteIfRequired(field) {
-        return this.requiresRewrite(field) ? `${field}.keyword` : field;
-    }
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var keyword_rewriter_exports = {};
+__export(keyword_rewriter_exports, {
+  KeywordRewriter: () => KeywordRewriter
+});
+module.exports = __toCommonJS(keyword_rewriter_exports);
+class KeywordRewriter {
+  fields;
+  constructor(fields) {
+    this.fields = new Set(fields);
+  }
+  add(field) {
+    this.fields.add(field);
+  }
+  remove(field) {
+    this.fields.delete(field);
+  }
+  requiresRewrite(field) {
+    return this.fields.has(field);
+  }
+  rewriteIfRequired(field) {
+    return this.requiresRewrite(field) ? `${field}.keyword` : field;
+  }
 }

package/search-index/elastic/model/elastic-query.js

@@ -1 +1,16 @@
-export {};
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var elastic_query_exports = {};
+module.exports = __toCommonJS(elastic_query_exports);