@classytic/arc 1.1.0 → 2.1.2

package/dist/adapters/index.js

@@ -1,668 +0,0 @@
-// src/adapters/types.ts
-function isMongooseModel(value) {
-  return typeof value === "function" && value.prototype && "modelName" in value && "schema" in value;
-}
-function isRepository(value) {
-  return typeof value === "object" && value !== null && "getAll" in value && "getById" in value && "create" in value && "update" in value && "delete" in value;
-}
-
-// src/adapters/mongoose.ts
-var MongooseAdapter = class {
-  type = "mongoose";
-  name;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any
-  model;
-  repository;
-  constructor(options) {
-    if (!isMongooseModel(options.model)) {
-      throw new TypeError(
-        "MongooseAdapter: Invalid model. Expected Mongoose Model instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })"
-      );
-    }
-    if (!isRepository(options.repository)) {
-      throw new TypeError(
-        "MongooseAdapter: Invalid repository. Expected CrudRepository instance.\nUsage: createMongooseAdapter({ model: YourModel, repository: yourRepo })"
-      );
-    }
-    this.model = options.model;
-    this.repository = options.repository;
-    this.name = `MongooseAdapter<${options.model.modelName}>`;
-  }
-  /**
-   * Get schema metadata from Mongoose model
-   */
-  getSchemaMetadata() {
-    const schema = this.model.schema;
-    const paths = schema.paths;
-    const fields = {};
-    for (const [fieldName, schemaType] of Object.entries(paths)) {
-      if (fieldName.startsWith("_") && fieldName !== "_id") continue;
-      const typeInfo = schemaType;
-      const mongooseType = typeInfo.instance || "Mixed";
-      const typeMap = {
-        String: "string",
-        Number: "number",
-        Boolean: "boolean",
-        Date: "date",
-        ObjectID: "objectId",
-        Array: "array",
-        Mixed: "object",
-        Buffer: "object",
-        Embedded: "object"
-      };
-      fields[fieldName] = {
-        type: typeMap[mongooseType] ?? "object",
-        required: !!typeInfo.isRequired,
-        ref: typeInfo.options?.ref
-      };
-    }
-    return {
-      name: this.model.modelName,
-      fields,
-      relations: this.extractRelations(paths)
-    };
-  }
-  /**
-   * Generate OpenAPI schemas from Mongoose model
-   */
-  generateSchemas(schemaOptions) {
-    try {
-      const schema = this.model.schema;
-      const paths = schema.paths;
-      const properties = {};
-      const required = [];
-      const fieldRules = schemaOptions?.fieldRules || {};
-      const blockedFields = new Set(
-        Object.entries(fieldRules).filter(([, rules]) => rules.systemManaged || rules.hidden).map(([field]) => field)
-      );
-      for (const [fieldName, schemaType] of Object.entries(paths)) {
-        if (fieldName.startsWith("__")) continue;
-        if (blockedFields.has(fieldName)) continue;
-        const typeInfo = schemaType;
-        properties[fieldName] = this.mongooseTypeToOpenApi(typeInfo);
-        if (typeInfo.isRequired) {
-          required.push(fieldName);
-        }
-      }
-      const baseSchema = {
-        type: "object",
-        properties,
-        required: required.length > 0 ? required : void 0
-      };
-      return {
-        create: {
-          body: {
-            ...baseSchema,
-            // Remove system-managed fields from create
-            properties: Object.fromEntries(
-              Object.entries(properties).filter(
-                ([field]) => !["_id", "createdAt", "updatedAt", "deletedAt"].includes(field)
-              )
-            )
-          }
-        },
-        update: {
-          body: {
-            ...baseSchema,
-            // All fields optional for PATCH
-            required: void 0,
-            properties: Object.fromEntries(
-              Object.entries(properties).filter(
-                ([field]) => !["_id", "createdAt", "updatedAt", "deletedAt"].includes(field)
-              )
-            )
-          }
-        },
-        response: {
-          type: "object",
-          properties
-        }
-      };
-    } catch {
-      return null;
-    }
-  }
-  /**
-   * Extract relation metadata
-   */
-  extractRelations(paths) {
-    const relations = {};
-    for (const [fieldName, schemaType] of Object.entries(paths)) {
-      const ref = schemaType.options?.ref;
-      if (ref) {
-        relations[fieldName] = {
-          type: "one-to-one",
-          // Mongoose refs are typically one-to-one
-          target: ref,
-          foreignKey: fieldName
-        };
-      }
-    }
-    return Object.keys(relations).length > 0 ? relations : void 0;
-  }
-  /**
-   * Convert Mongoose type to OpenAPI type
-   */
-  mongooseTypeToOpenApi(typeInfo) {
-    const instance = typeInfo.instance;
-    const options = typeInfo.options || {};
-    const baseType = {};
-    switch (instance) {
-      case "String":
-        baseType.type = "string";
-        if (options.enum) baseType.enum = options.enum;
-        if (options.minlength) baseType.minLength = options.minlength;
-        if (options.maxlength) baseType.maxLength = options.maxlength;
-        break;
-      case "Number":
-        baseType.type = "number";
-        if (options.min !== void 0) baseType.minimum = options.min;
-        if (options.max !== void 0) baseType.maximum = options.max;
-        break;
-      case "Boolean":
-        baseType.type = "boolean";
-        break;
-      case "Date":
-        baseType.type = "string";
-        baseType.format = "date-time";
-        break;
-      case "ObjectID":
-        baseType.type = "string";
-        baseType.pattern = "^[a-f\\d]{24}$";
-        break;
-      case "Array":
-        baseType.type = "array";
-        baseType.items = { type: "string" };
-        break;
-      default:
-        baseType.type = "object";
-    }
-    return baseType;
-  }
-};
-function createMongooseAdapter(options) {
-  return new MongooseAdapter(options);
-}
-
-// src/adapters/prisma.ts
-var PrismaQueryParser = class {
-  maxLimit;
-  defaultLimit;
-  softDeleteEnabled;
-  softDeleteField;
-  /** Map Arc operators to Prisma operators */
-  operatorMap = {
-    $eq: "equals",
-    $ne: "not",
-    $gt: "gt",
-    $gte: "gte",
-    $lt: "lt",
-    $lte: "lte",
-    $in: "in",
-    $nin: "notIn",
-    $regex: "contains",
-    $exists: void 0
-    // Handled specially
-  };
-  constructor(options = {}) {
-    this.maxLimit = options.maxLimit ?? 1e3;
-    this.defaultLimit = options.defaultLimit ?? 20;
-    this.softDeleteEnabled = options.softDeleteEnabled ?? true;
-    this.softDeleteField = options.softDeleteField ?? "deletedAt";
-  }
-  /**
-   * Parse URL query parameters (delegates to ArcQueryParser format)
-   */
-  parse(query) {
-    const q = query ?? {};
-    const page = this.parseNumber(q.page, 1);
-    const limit = Math.min(this.parseNumber(q.limit, this.defaultLimit), this.maxLimit);
-    return {
-      filters: this.parseFilters(q),
-      limit,
-      page,
-      sort: this.parseSort(q.sort),
-      search: q.search,
-      select: this.parseSelect(q.select)
-    };
-  }
-  /**
-   * Convert ParsedQuery to Prisma query options
-   */
-  toPrismaQuery(parsed, policyFilters) {
-    const where = {};
-    if (parsed.filters) {
-      Object.assign(where, this.translateFilters(parsed.filters));
-    }
-    if (policyFilters) {
-      Object.assign(where, this.translateFilters(policyFilters));
-    }
-    if (this.softDeleteEnabled) {
-      where[this.softDeleteField] = null;
-    }
-    const orderBy = parsed.sort ? Object.entries(parsed.sort).map(([field, dir]) => ({
-      [field]: dir === 1 ? "asc" : "desc"
-    })) : void 0;
-    const take = parsed.limit ?? this.defaultLimit;
-    const skip = parsed.page ? (parsed.page - 1) * take : 0;
-    const select = parsed.select ? Object.fromEntries(
-      Object.entries(parsed.select).filter(([, v]) => v === 1).map(([k]) => [k, true])
-    ) : void 0;
-    return {
-      where: Object.keys(where).length > 0 ? where : void 0,
-      orderBy: orderBy && orderBy.length > 0 ? orderBy : void 0,
-      take,
-      skip,
-      select: select && Object.keys(select).length > 0 ? select : void 0
-    };
-  }
-  /**
-   * Translate Arc/MongoDB-style filters to Prisma where clause
-   */
-  translateFilters(filters) {
-    const result = {};
-    for (const [field, value] of Object.entries(filters)) {
-      if (value === null || value === void 0) continue;
-      if (typeof value === "object" && !Array.isArray(value)) {
-        const prismaCondition = {};
-        for (const [op, opValue] of Object.entries(value)) {
-          if (op === "$exists") {
-            result[field] = opValue ? { not: null } : null;
-            continue;
-          }
-          const prismaOp = this.operatorMap[op];
-          if (prismaOp) {
-            prismaCondition[prismaOp] = opValue;
-          }
-        }
-        if (Object.keys(prismaCondition).length > 0) {
-          result[field] = prismaCondition;
-        }
-      } else {
-        result[field] = value;
-      }
-    }
-    return result;
-  }
-  parseNumber(value, defaultValue) {
-    if (value === void 0 || value === null) return defaultValue;
-    const num = parseInt(String(value), 10);
-    return Number.isNaN(num) ? defaultValue : Math.max(1, num);
-  }
-  parseSort(value) {
-    if (!value) return void 0;
-    const sortStr = String(value);
-    const result = {};
-    for (const field of sortStr.split(",")) {
-      const trimmed = field.trim();
-      if (!trimmed || !/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(trimmed)) continue;
-      if (trimmed.startsWith("-")) {
-        result[trimmed.slice(1)] = -1;
-      } else {
-        result[trimmed] = 1;
-      }
-    }
-    return Object.keys(result).length > 0 ? result : void 0;
-  }
-  parseSelect(value) {
-    if (!value) return void 0;
-    const result = {};
-    for (const field of String(value).split(",")) {
-      const trimmed = field.trim();
-      if (!trimmed || !/^-?[a-zA-Z_][a-zA-Z0-9_.]*$/.test(trimmed)) continue;
-      result[trimmed.startsWith("-") ? trimmed.slice(1) : trimmed] = trimmed.startsWith("-") ? 0 : 1;
-    }
-    return Object.keys(result).length > 0 ? result : void 0;
-  }
-  parseFilters(query) {
-    const reserved = /* @__PURE__ */ new Set(["page", "limit", "sort", "search", "select", "populate", "after", "cursor"]);
-    const filters = {};
-    const operators = {
-      eq: "$eq",
-      ne: "$ne",
-      gt: "$gt",
-      gte: "$gte",
-      lt: "$lt",
-      lte: "$lte",
-      in: "$in",
-      nin: "$nin",
-      like: "$regex",
-      contains: "$regex",
-      exists: "$exists"
-    };
-    for (const [key, value] of Object.entries(query)) {
-      if (reserved.has(key) || value === void 0 || value === null) continue;
-      const match = key.match(/^([a-zA-Z_][a-zA-Z0-9_.]*)(?:\[([a-z]+)\])?$/);
-      if (!match) continue;
-      const [, fieldName, operator] = match;
-      if (!fieldName) continue;
-      if (operator && operators[operator]) {
-        if (!filters[fieldName]) filters[fieldName] = {};
-        filters[fieldName][operators[operator]] = this.coerceValue(value, operator);
-      } else if (!operator) {
-        filters[fieldName] = this.coerceValue(value);
-      }
-    }
-    return filters;
-  }
-  coerceValue(value, operator) {
-    if (operator === "in" || operator === "nin") {
-      if (Array.isArray(value)) return value.map((v) => this.coerceValue(v));
-      if (typeof value === "string" && value.includes(",")) {
-        return value.split(",").map((v) => this.coerceValue(v.trim()));
-      }
-      return [this.coerceValue(value)];
-    }
-    if (operator === "exists") {
-      return String(value).toLowerCase() === "true" || value === "1";
-    }
-    if (value === "true") return true;
-    if (value === "false") return false;
-    if (value === "null") return null;
-    if (typeof value === "string") {
-      const num = Number(value);
-      if (!Number.isNaN(num) && value.trim() !== "") return num;
-    }
-    return value;
-  }
-};
-var PrismaAdapter = class {
-  type = "prisma";
-  name;
-  repository;
-  queryParser;
-  client;
-  modelName;
-  dmmf;
-  softDeleteEnabled;
-  softDeleteField;
-  constructor(options) {
-    this.client = options.client;
-    this.modelName = options.modelName;
-    this.repository = options.repository;
-    this.dmmf = options.dmmf;
-    this.name = `prisma:${options.modelName}`;
-    this.softDeleteEnabled = options.softDeleteEnabled ?? true;
-    this.softDeleteField = options.softDeleteField ?? "deletedAt";
-    this.queryParser = options.queryParser ?? new PrismaQueryParser({
-      softDeleteEnabled: this.softDeleteEnabled,
-      softDeleteField: this.softDeleteField
-    });
-  }
-  /**
-   * Parse URL query parameters and convert to Prisma query options
-   */
-  parseQuery(query, policyFilters) {
-    const parsed = this.queryParser.parse(query);
-    return this.queryParser.toPrismaQuery(parsed, policyFilters);
-  }
-  /**
-   * Apply policy filters to existing Prisma where clause
-   * Used for multi-tenant, ownership, and other security filters
-   */
-  applyPolicyFilters(where, policyFilters) {
-    return { ...where, ...policyFilters };
-  }
-  generateSchemas(options) {
-    if (!this.dmmf) return null;
-    try {
-      const model = this.dmmf.datamodel?.models?.find(
-        (m) => m.name.toLowerCase() === this.modelName.toLowerCase()
-      );
-      if (!model) return null;
-      const entitySchema = this.buildEntitySchema(model, options);
-      const createBodySchema = this.buildCreateSchema(model, options);
-      const updateBodySchema = this.buildUpdateSchema(model, options);
-      return {
-        entity: entitySchema,
-        createBody: createBodySchema,
-        updateBody: updateBodySchema,
-        params: {
-          type: "object",
-          properties: {
-            id: { type: "string" }
-          },
-          required: ["id"]
-        },
-        listQuery: {
-          type: "object",
-          properties: {
-            page: { type: "number", minimum: 1, description: "Page number for pagination" },
-            limit: { type: "number", minimum: 1, maximum: 100, description: "Items per page" },
-            sort: { type: "string", description: 'Sort field (e.g., "name", "-createdAt")' }
-            // Note: Actual filtering requires custom query parser implementation
-            // This is placeholder documentation only
-          }
-        }
-      };
-    } catch {
-      return null;
-    }
-  }
-  getSchemaMetadata() {
-    if (!this.dmmf) return null;
-    try {
-      const model = this.dmmf.datamodel?.models?.find(
-        (m) => m.name.toLowerCase() === this.modelName.toLowerCase()
-      );
-      if (!model) return null;
-      const fields = {};
-      for (const field of model.fields) {
-        fields[field.name] = this.convertPrismaFieldToMetadata(field);
-      }
-      return {
-        name: model.name,
-        fields,
-        indexes: model.uniqueIndexes?.map((idx) => ({
-          fields: idx.fields,
-          unique: true
-        }))
-      };
-    } catch (err) {
-      return null;
-    }
-  }
-  async validate(data) {
-    if (!data || typeof data !== "object") {
-      return {
-        valid: false,
-        errors: [{ field: "root", message: "Data must be an object" }]
-      };
-    }
-    if (this.dmmf) {
-      try {
-        const model = this.dmmf.datamodel?.models?.find(
-          (m) => m.name.toLowerCase() === this.modelName.toLowerCase()
-        );
-        if (model) {
-          const requiredFields = model.fields.filter(
-            (f) => f.isRequired && !f.hasDefaultValue && !f.isGenerated
-          );
-          const errors = [];
-          for (const field of requiredFields) {
-            if (!(field.name in data)) {
-              errors.push({
-                field: field.name,
-                message: `${field.name} is required`
-              });
-            }
-          }
-          if (errors.length > 0) {
-            return { valid: false, errors };
-          }
-        }
-      } catch (err) {
-      }
-    }
-    return { valid: true };
-  }
-  async healthCheck() {
-    try {
-      const delegateName = this.modelName.charAt(0).toLowerCase() + this.modelName.slice(1);
-      const delegate = this.client[delegateName];
-      if (!delegate) {
-        return false;
-      }
-      await delegate.findMany({ take: 1 });
-      return true;
-    } catch (err) {
-      return false;
-    }
-  }
-  async close() {
-    try {
-      await this.client.$disconnect();
-    } catch (err) {
-    }
-  }
-  // ============================================================================
-  // Private Helper Methods
-  // ============================================================================
-  buildEntitySchema(model, options) {
-    const properties = {};
-    const required = [];
-    for (const field of model.fields) {
-      if (this.shouldSkipField(field, options)) continue;
-      properties[field.name] = this.convertPrismaFieldToJsonSchema(field);
-      if (field.isRequired && !field.hasDefaultValue) {
-        required.push(field.name);
-      }
-    }
-    return {
-      type: "object",
-      properties,
-      ...required.length > 0 && { required }
-    };
-  }
-  buildCreateSchema(model, options) {
-    const properties = {};
-    const required = [];
-    for (const field of model.fields) {
-      if (field.isGenerated || field.relationName) continue;
-      if (this.shouldSkipField(field, options)) continue;
-      properties[field.name] = this.convertPrismaFieldToJsonSchema(field);
-      if (field.isRequired && !field.hasDefaultValue) {
-        required.push(field.name);
-      }
-    }
-    return {
-      type: "object",
-      properties,
-      ...required.length > 0 && { required }
-    };
-  }
-  buildUpdateSchema(model, options) {
-    const properties = {};
-    for (const field of model.fields) {
-      if (field.isGenerated || field.isId || field.relationName) continue;
-      if (this.shouldSkipField(field, options)) continue;
-      properties[field.name] = this.convertPrismaFieldToJsonSchema(field);
-    }
-    return {
-      type: "object",
-      properties
-    };
-  }
-  shouldSkipField(field, options) {
-    if (options?.excludeFields?.includes(field.name)) {
-      return true;
-    }
-    if (field.name.startsWith("_")) {
-      return true;
-    }
-    return false;
-  }
-  convertPrismaFieldToJsonSchema(field) {
-    const schema = {};
-    switch (field.type) {
-      case "String":
-        schema.type = "string";
-        break;
-      case "Int":
-      case "BigInt":
-        schema.type = "integer";
-        break;
-      case "Float":
-      case "Decimal":
-        schema.type = "number";
-        break;
-      case "Boolean":
-        schema.type = "boolean";
-        break;
-      case "DateTime":
-        schema.type = "string";
-        schema.format = "date-time";
-        break;
-      case "Json":
-        schema.type = "object";
-        break;
-      default:
-        if (field.kind === "enum") {
-          schema.type = "string";
-          if (this.dmmf?.datamodel?.enums) {
-            const enumDef = this.dmmf.datamodel.enums.find((e) => e.name === field.type);
-            if (enumDef) {
-              schema.enum = enumDef.values.map((v) => v.name);
-            }
-          }
-        } else {
-          schema.type = "string";
-        }
-    }
-    if (field.isList) {
-      return {
-        type: "array",
-        items: schema
-      };
-    }
-    if (field.documentation) {
-      schema.description = field.documentation;
-    }
-    return schema;
-  }
-  convertPrismaFieldToMetadata(field) {
-    const metadata = {
-      type: this.mapPrismaTypeToMetadataType(field.type, field.kind),
-      required: field.isRequired,
-      array: field.isList
-    };
-    if (field.isUnique) {
-      metadata.unique = true;
-    }
-    if (field.hasDefaultValue) {
-      metadata.default = field.default;
-    }
-    if (field.documentation) {
-      metadata.description = field.documentation;
-    }
-    if (field.relationName) {
-      metadata.ref = field.type;
-    }
-    return metadata;
-  }
-  mapPrismaTypeToMetadataType(type, kind) {
-    if (kind === "enum") return "enum";
-    switch (type) {
-      case "String":
-        return "string";
-      case "Int":
-      case "BigInt":
-      case "Float":
-      case "Decimal":
-        return "number";
-      case "Boolean":
-        return "boolean";
-      case "DateTime":
-        return "date";
-      case "Json":
-        return "object";
-      default:
-        return "string";
-    }
-  }
-};
-function createPrismaAdapter(options) {
-  return new PrismaAdapter(options);
-}
-
-export { MongooseAdapter, PrismaAdapter, PrismaQueryParser, createMongooseAdapter, createPrismaAdapter };