@classytic/arc 1.0.0

package/dist/adapters/index.js

@@ -0,0 +1,668 @@
+// 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 };