@magnet-cms/common 0.1.0

package/dist/index.cjs

@@ -0,0 +1,395 @@
+'use strict';
+
+require('reflect-metadata');
+var fs = require('fs');
+var path = require('path');
+var common = require('@nestjs/common');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/constants.ts
+var RESOLVER_METADATA_KEY = "magnet:resolver";
+var RESOLVE_METADATA_KEY = "magnet:resolve";
+var SCHEMA_METADATA_KEY = "magnet:schema";
+var SCHEMA_OPTIONS_METADATA_KEY = "magnet:schema:options";
+var BASE_SCHEMA_METADATA_KEY = "magnet:schema:base";
+var PROP_METADATA_KEY = "magnet:schema:prop";
+var UI_METADATA_KEY = "magnet:schema:ui";
+var SETTING_METADATA_KEY = "magnet:setting";
+var INJECT_MODEL = "magnet:inject:model";
+var DESIGN_TYPE = "design:type";
+var DESIGN_META = "design:metadata";
+var DESIGN_PARAM_TYPES = "design:paramtypes";
+var DESIGN_RETURN_TYPE = "design:returntype";
+
+// src/decorators/resolver/resolver.decorator.ts
+function Resolver(optionsOrFn) {
+  return (target) => {
+    let resolvedOptions;
+    if (typeof optionsOrFn === "function") {
+      resolvedOptions = {
+        schema: optionsOrFn()
+      };
+    } else {
+      if (!optionsOrFn.schema) {
+        throw new Error(`@Resolver object input must include a 'schema' property.`);
+      }
+      resolvedOptions = optionsOrFn;
+    }
+    Reflect.defineMetadata(RESOLVER_METADATA_KEY, resolvedOptions, target);
+  };
+}
+__name(Resolver, "Resolver");
+
+// src/decorators/resolver/resolve.decorator.ts
+function Resolve(optionsOrFn) {
+  return (target, propertyKey, descriptor) => {
+    const controller = target.constructor;
+    let resolvedOptions;
+    if (typeof optionsOrFn === "function") {
+      const resolvedType = optionsOrFn();
+      resolvedOptions = {
+        type: resolvedType,
+        isArray: false
+      };
+    } else if (Array.isArray(optionsOrFn)) {
+      if (!optionsOrFn.every((fn) => typeof fn === "function")) {
+        throw new Error("@Resolve array input must only contain functions.");
+      }
+      resolvedOptions = {
+        type: optionsOrFn.map((fn) => fn()),
+        isArray: true
+      };
+    } else {
+      if (!optionsOrFn || !optionsOrFn.type) {
+        throw new Error(`@Resolve object input must include a 'type' property.`);
+      }
+      resolvedOptions = {
+        ...optionsOrFn,
+        isArray: Array.isArray(optionsOrFn.type)
+      };
+    }
+    if (!descriptor.value) {
+      throw new Error(`@Resolve must be used within a method. Class: ${controller.name}`);
+    }
+    Reflect.defineMetadata(RESOLVE_METADATA_KEY, resolvedOptions, descriptor.value);
+  };
+}
+__name(Resolve, "Resolve");
+var cachedAdapter = null;
+function isPackageInstalled(packageName) {
+  try {
+    return fs.existsSync(path.join(__require.resolve(packageName), "../../"));
+  } catch {
+    return false;
+  }
+}
+__name(isPackageInstalled, "isPackageInstalled");
+function detectDatabaseAdapter() {
+  if (cachedAdapter) return cachedAdapter;
+  if (isPackageInstalled("@magnet-cms/adapter-mongoose")) {
+    cachedAdapter = "mongoose";
+  } else if (isPackageInstalled("@magnet-cms/adapter-typeorm")) {
+    cachedAdapter = "typeorm";
+  } else {
+    throw new Error("\u274C No supported database adapter found. Install @magnet-cms/adapter-mongoose or @magnet-cms/adapter-typeorm.");
+  }
+  return cachedAdapter;
+}
+__name(detectDatabaseAdapter, "detectDatabaseAdapter");
+
+// src/utils/get-model-token.util.ts
+function getModelToken(schema) {
+  return `Magnet${schema.name}Model`;
+}
+__name(getModelToken, "getModelToken");
+
+// src/utils/get-schema-token.util.ts
+var getSchemaToken = /* @__PURE__ */ __name((schema) => {
+  return `${schema.name}Schema`;
+}, "getSchemaToken");
+var getSettingToken = /* @__PURE__ */ __name((setting) => {
+  return `${setting.name}Setting`;
+}, "getSettingToken");
+
+// src/decorators/schema/prop.decorator.ts
+function Prop(options) {
+  return (target, propertyKey) => {
+    const adapter = detectDatabaseAdapter();
+    const existingProps = Reflect.getMetadata(PROP_METADATA_KEY, target) || [];
+    Reflect.defineMetadata(PROP_METADATA_KEY, [
+      ...existingProps,
+      {
+        propertyKey,
+        options
+      }
+    ], target);
+    const { Prop: Prop2 } = __require(`@magnet-cms/adapter-${adapter}`);
+    return Prop2(options)(target, propertyKey);
+  };
+}
+__name(Prop, "Prop");
+
+// src/decorators/schema/schema.decorator.ts
+var defaultSchemaOptions = {
+  versioning: true,
+  i18n: true
+};
+function Schema(options = {}) {
+  return (target) => {
+    const adapter = detectDatabaseAdapter();
+    const mergedOptions = {
+      ...defaultSchemaOptions,
+      ...options
+    };
+    Reflect.defineMetadata(SCHEMA_METADATA_KEY, true, target);
+    Reflect.defineMetadata(SCHEMA_OPTIONS_METADATA_KEY, mergedOptions, target);
+    const { Schema: Schema2 } = __require(`@magnet-cms/adapter-${adapter}`);
+    return Schema2()(target);
+  };
+}
+__name(Schema, "Schema");
+function getSchemaOptions(target) {
+  return Reflect.getMetadata(SCHEMA_OPTIONS_METADATA_KEY, target) || defaultSchemaOptions;
+}
+__name(getSchemaOptions, "getSchemaOptions");
+
+// src/decorators/schema/setting.decorator.ts
+function Setting() {
+  return (target) => {
+    Reflect.defineMetadata(SETTING_METADATA_KEY, true, target);
+  };
+}
+__name(Setting, "Setting");
+
+// src/decorators/schema/ui.decorator.ts
+function UI(options) {
+  return (target, propertyKey) => {
+    const designType = Reflect.getMetadata("design:type", target, propertyKey);
+    const existingUIFields = Reflect.getMetadata(UI_METADATA_KEY, target) || [];
+    Reflect.defineMetadata(UI_METADATA_KEY, [
+      ...existingUIFields,
+      {
+        propertyKey,
+        options: {
+          ...options,
+          designType
+        }
+      }
+    ], target);
+  };
+}
+__name(UI, "UI");
+var Validators = /* @__PURE__ */ __name((...validators) => {
+  return common.applyDecorators(...validators);
+}, "Validators");
+
+// src/decorators/schema/version.decorator.ts
+var VERSION_METADATA_KEY = "version:metadata";
+function Version(config = {}) {
+  return (target) => {
+    Reflect.defineMetadata(VERSION_METADATA_KEY, config, target);
+  };
+}
+__name(Version, "Version");
+
+// src/decorators/inject.decorator.ts
+function InjectModel(model) {
+  return (target, propertyKey, parameterIndex) => {
+    const adapter = detectDatabaseAdapter();
+    if (propertyKey !== void 0) {
+      Reflect.defineMetadata(INJECT_MODEL, model, target, propertyKey);
+    }
+    const { InjectModel: InjectModel2 } = __require(`@magnet-cms/adapter-${adapter}`);
+    return InjectModel2(model)(target, propertyKey, parameterIndex);
+  };
+}
+__name(InjectModel, "InjectModel");
+
+// src/exceptions/validation.exception.ts
+var ValidationException = class extends Error {
+  static {
+    __name(this, "ValidationException");
+  }
+  errors;
+  constructor(errors) {
+    super("ValidationException"), this.errors = errors;
+  }
+};
+
+// src/model/base.model.ts
+var Model = class {
+  static {
+    __name(this, "Model");
+  }
+  /**
+  * Set the version for subsequent operations
+  * @param versionId The version ID or status ('draft', 'published', 'archived')
+  */
+  version(versionId) {
+    return this;
+  }
+  /**
+  * Find all versions of a document
+  * @param documentId The document ID
+  */
+  findVersions(documentId) {
+    return Promise.resolve([]);
+  }
+  /**
+  * Find a specific version by ID
+  * @param versionId The version ID
+  */
+  findVersionById(versionId) {
+    return Promise.resolve(null);
+  }
+  /**
+  * Restore a version
+  * @param versionId The version ID to restore
+  */
+  restoreVersion(versionId) {
+    return Promise.resolve(null);
+  }
+  /**
+  * Create a query builder for advanced queries with sorting, pagination, and operators.
+  * The query builder inherits the current locale/version context.
+  *
+  * @example
+  * ```typescript
+  * const results = await model.query()
+  *   .where({ status: 'active', age: { $gte: 18 } })
+  *   .sort({ createdAt: -1 })
+  *   .limit(10)
+  *   .exec()
+  * ```
+  */
+  query() {
+    throw new Error("QueryBuilder not implemented by this adapter");
+  }
+  /**
+  * Get access to the native database model/collection.
+  * Use with caution - bypasses Magnet abstractions like locale and versioning.
+  *
+  * @returns The underlying database model (e.g., Mongoose Model)
+  */
+  native() {
+    throw new Error("Native access not implemented by this adapter");
+  }
+};
+
+// src/model/mixed.model.ts
+var Mixed = class {
+  static {
+    __name(this, "Mixed");
+  }
+  static schemaName;
+  defaultOptions;
+};
+
+// src/model/query-builder.ts
+var QueryBuilder = class {
+  static {
+    __name(this, "QueryBuilder");
+  }
+};
+
+// src/types/auth.types.ts
+var AuthStrategy = class {
+  static {
+    __name(this, "AuthStrategy");
+  }
+  /**
+  * Get the Passport strategy name (for guards)
+  * Returns the name to use with AuthGuard()
+  */
+  getPassportStrategyName() {
+    return this.name;
+  }
+};
+
+// src/types/config.types.ts
+var MagnetModuleOptions = class {
+  static {
+    __name(this, "MagnetModuleOptions");
+  }
+  db;
+  jwt;
+  /**
+  * Auth configuration (optional, uses JWT by default)
+  */
+  auth;
+  internationalization;
+  playground;
+  storage;
+  /**
+  * Plugins to load with the Magnet module
+  */
+  plugins;
+  constructor({ db, jwt, auth, internationalization, playground, storage, plugins }) {
+    this.db = db;
+    this.jwt = jwt;
+    this.auth = auth;
+    this.internationalization = internationalization;
+    this.playground = playground;
+    this.storage = storage;
+    this.plugins = plugins;
+  }
+};
+
+// src/types/database.types.ts
+var DatabaseAdapter = class {
+  static {
+    __name(this, "DatabaseAdapter");
+  }
+};
+
+// src/types/storage.types.ts
+var StorageAdapter = class {
+  static {
+    __name(this, "StorageAdapter");
+  }
+};
+
+exports.AuthStrategy = AuthStrategy;
+exports.BASE_SCHEMA_METADATA_KEY = BASE_SCHEMA_METADATA_KEY;
+exports.DESIGN_META = DESIGN_META;
+exports.DESIGN_PARAM_TYPES = DESIGN_PARAM_TYPES;
+exports.DESIGN_RETURN_TYPE = DESIGN_RETURN_TYPE;
+exports.DESIGN_TYPE = DESIGN_TYPE;
+exports.DatabaseAdapter = DatabaseAdapter;
+exports.INJECT_MODEL = INJECT_MODEL;
+exports.InjectModel = InjectModel;
+exports.MagnetModuleOptions = MagnetModuleOptions;
+exports.Mixed = Mixed;
+exports.Model = Model;
+exports.PROP_METADATA_KEY = PROP_METADATA_KEY;
+exports.Prop = Prop;
+exports.QueryBuilder = QueryBuilder;
+exports.RESOLVER_METADATA_KEY = RESOLVER_METADATA_KEY;
+exports.RESOLVE_METADATA_KEY = RESOLVE_METADATA_KEY;
+exports.Resolve = Resolve;
+exports.Resolver = Resolver;
+exports.SCHEMA_METADATA_KEY = SCHEMA_METADATA_KEY;
+exports.SCHEMA_OPTIONS_METADATA_KEY = SCHEMA_OPTIONS_METADATA_KEY;
+exports.SETTING_METADATA_KEY = SETTING_METADATA_KEY;
+exports.Schema = Schema;
+exports.Setting = Setting;
+exports.StorageAdapter = StorageAdapter;
+exports.UI = UI;
+exports.UI_METADATA_KEY = UI_METADATA_KEY;
+exports.VERSION_METADATA_KEY = VERSION_METADATA_KEY;
+exports.ValidationException = ValidationException;
+exports.Validators = Validators;
+exports.Version = Version;
+exports.detectDatabaseAdapter = detectDatabaseAdapter;
+exports.getModelToken = getModelToken;
+exports.getSchemaOptions = getSchemaOptions;
+exports.getSchemaToken = getSchemaToken;
+exports.getSettingToken = getSettingToken;