feat: Base Model + FieldRef + utils (+ fix pre-commit + fix eslintconf)

Author: devthejo

.husky/pre-commit

@@ -1,4 +1,13 @@
-#!/usr/bin/env sh
-. "$(dirname -- "$0")/_/husky.sh"
+# Ajouter le PATH de base pour avoir accès à direnv
+export PATH="$HOME/.nix-profile/bin:/nix/var/nix/profiles/default/bin:$PATH"
+
+# Si direnv est disponible, récupérer le PATH du projet via bash
+if [ -f ".envrc" ] && command -v direnv >/dev/null 2>&1; then
+    # Utiliser bash pour exécuter direnv et extraire seulement le PATH
+    PROJECT_PATH=$(bash -c 'eval "$(direnv export bash 2>/dev/null)" && echo "$PATH"')
+    if [ -n "$PROJECT_PATH" ]; then
+        export PATH="$PROJECT_PATH"
+    fi
+fi
 
 yarn lint-staged

eslint.config.mjs

@@ -81,12 +81,14 @@ export default defineConfig([
 
     rules: {
       "@typescript-eslint/explicit-function-return-type": "off",
-      "@typescript-eslint/no-explicit-any": "warn",
+      "@typescript-eslint/no-explicit-any": "off",
 
       "@typescript-eslint/no-unused-vars": [
         "error",
         {
-          argsIgnorePattern: "^_",
+          'argsIgnorePattern': '^_',
+          'varsIgnorePattern': '^_',
+          'caughtErrorsIgnorePattern': '^_',
         },
       ],
 

packages/sdk/index.ts

@@ -2,4 +2,8 @@
 export { logger, createLogger } from "@crossplane-js/libs"
 
 // Export types
-export type * from "./types"
+export type * from "./src/types"
+
+export * from "./src/Model"
+export * from "./src/utils/FieldRef"
+export * from "./src/utils/secretUtils"

packages/sdk/package.json

@@ -6,6 +6,8 @@
   "main": "index.ts",
   "dependencies": {
     "@crossplane-js/libs": "workspace:^",
+    "@kubernetes-models/apimachinery": "^2.1.0",
+    "@kubernetes-models/base": "^5.0.1",
     "lodash": "^4.17.21",
     "pino": "^9.6.0",
     "yaml": "^2.7.0"

packages/sdk/src/Model/index.ts

@@ -0,0 +1,171 @@
+import type { IObjectMeta } from "@kubernetes-models/apimachinery/apis/meta/v1/ObjectMeta"
+import { Model as BaseModel } from "@kubernetes-models/base"
+
+type Condition = Array<{
+  type: string
+  status: string
+  lastTransitionTime: string
+  message?: string
+  reason: string
+}>
+type Status = {
+  conditions?: Condition
+  [key: string]: any
+}
+
+export class Model<T> extends BaseModel<T> {
+  getMetadata(): IObjectMeta {
+    const self = this as any
+    if (!self.metadatata) {
+      throw new Error("No metadata found")
+    }
+    return self.metadata
+  }
+
+  getStatus(): Status {
+    const self = this as any
+    return self.status || {}
+  }
+
+  /**
+   * Get the claim namespace from annotations (legacy method)
+   * @returns The claim namespace
+   * @throws Error if the resource wasn't created via a claim
+   */
+  getClaimNamespace(): string {
+    const { name } = this.getMetadata()
+    const claimNamespace = this.getMetadata().labels?.["crossplane.io/claim-namespace"]
+
+    if (!claimNamespace) {
+      throw new Error(`Resource ${name} wasn't created via a claim`)
+    }
+
+    return claimNamespace
+  }
+
+  /**
+   * Check if this resource is ready based on its status conditions
+   * @returns true if the resource is ready, false otherwise
+   */
+  isReady(): boolean {
+    try {
+      // ProviderConfigs don't have status conditions, we assume they're always ready
+      if ((this as any).kind === "ProviderConfig") {
+        return true
+      }
+
+      // Check for Ready condition in status.conditions
+      const conditions = this.getStatus()?.conditions
+      if (!conditions || !Array.isArray(conditions)) {
+        return false
+      }
+
+      const readyCondition = conditions.find((condition: any) => condition.type === "Ready")
+      return readyCondition?.status === "True"
+    } catch (_error) {
+      return false
+    }
+  }
+
+  /**
+   * Get a specific condition from the resource status
+   * @param conditionType - The type of condition to find
+   * @returns The condition object or undefined if not found
+   */
+  getCondition(
+    conditionType: string
+  ):
+    | { type: string; status: string; lastTransitionTime: string; message?: string; reason: string }
+    | undefined {
+    return this.getStatus()?.conditions?.find(condition => condition.type === conditionType)
+  }
+
+  /**
+   * Check if a specific condition is true
+   * @param conditionType - The type of condition to check
+   * @returns true if the condition exists and its status is "True"
+   */
+  hasCondition(conditionType: string): boolean {
+    const condition = this.getCondition(conditionType)
+    return condition?.status === "True"
+  }
+
+  /**
+   * Get the resource name
+   * @returns The resource name
+   */
+  getName(): string | undefined {
+    return this.getMetadata().name
+  }
+
+  /**
+   * Get the resource namespace
+   * @returns The resource namespace or undefined if not set
+   */
+  getNamespace(): string | undefined {
+    return this.getMetadata().namespace
+  }
+
+  /**
+   * Get an annotation value
+   * @param key - The annotation key
+   * @returns The annotation value or undefined if not found
+   */
+  getAnnotation(key: string): string | undefined {
+    return this.getMetadata().annotations?.[key]
+  }
+
+  /**
+   * Get a label value
+   * @param key - The label key
+   * @returns The label value or undefined if not found
+   */
+  getLabel(key: string): string | undefined {
+    return this.getMetadata().labels?.[key]
+  }
+
+  /**
+   * Check if the resource is paused
+   * @returns true if the resource has the pause annotation set to "true"
+   */
+  isPaused(): boolean {
+    return this.getAnnotation("crossplane.io/paused") === "true"
+  }
+
+  /**
+   * Create a Usage resource to establish dependency relationships between resources
+   * @param byResource - Optional resource that uses this resource
+   * @returns Usage resource object
+   */
+  makeUsage(byResource?: Model<any>): any {
+    const usageName = byResource
+      ? `${byResource.getMetadata().name}-uses-${this.getMetadata().name}`
+      : `protect-${this.getMetadata().name}`
+
+    const usage: any = {
+      apiVersion: "apiextensions.crossplane.io/v1alpha1",
+      kind: "Usage",
+      getMetadata() {
+        return usageName
+      },
+      spec: {
+        replayDeletion: true,
+        of: {
+          apiVersion: (this as any).apiVersion,
+          kind: (this as any).kind,
+          resourceRef: { name: this.getMetadata().name },
+        },
+      },
+    }
+
+    if (byResource) {
+      usage.spec.by = {
+        apiVersion: (byResource as any).apiVersion,
+        kind: (byResource as any).kind,
+        resourceRef: { name: byResource.getMetadata().name },
+      }
+    }
+
+    return usage
+  }
+}

packages/sdk/types.ts renamed to packages/sdk/src/types.ts

@@ -0,0 +1,116 @@
+import lodash from "lodash"
+
+/**
+ * A reference to a field in an object, with fallback in case the field is not found.
+ * Used to reference a value when declaring a composed resource. If the field is not found,
+ * the resource will be set with a wrong value, but it will be paused, until a compose
+ * function is called again with the correct values.
+ */
+export class FieldRef<T> extends String {
+  private resolved: boolean
+
+  static getValue<T>(
+    valueContainer: Record<string, any>,
+    path: string,
+    fallback: T,
+    valueTransformer?: (value: any) => T
+  ): [T, boolean] {
+    const obj = lodash.get(valueContainer, path)
+    if (obj === undefined) {
+      return [fallback, false]
+    }
+    const transformedValue = valueTransformer ? valueTransformer(obj) : (obj as T)
+    return [transformedValue, true]
+  }
+
+  constructor(
+    valueContainer: Record<string, any>,
+    path: string,
+    fallback: T,
+    valueTransformer?: (value: any) => T
+  ) {
+    const value = FieldRef.getValue<T>(valueContainer, path, fallback, valueTransformer)
+    super(value[0])
+    this.resolved = value[1]
+  }
+
+  /**
+   * Check if the field reference can be resolved
+   * @returns true if the field can be resolved, false otherwise
+   */
+  canResolve(): boolean {
+    return this.resolved
+  }
+}
+
+/**
+ * Type that recursively transforms all string properties to accept either string or FieldRef<string>
+ */
+type WithFieldRefs<T> = T extends string
+  ? string | FieldRef<string>
+  : T extends number
+    ? number | FieldRef<number>
+    : T extends boolean
+      ? boolean | FieldRef<boolean>
+      : T extends (infer U)[]
+        ? WithFieldRefs<U>[]
+        : T extends object
+          ? { [K in keyof T]: WithFieldRefs<T[K]> }
+          : T
+
+/**
+ * Factory function that creates a new class allowing FieldRef values in place of primitive types
+ * @param BaseClass The original Kubernetes model class
+ * @returns A new class that accepts FieldRef instances for primitive properties
+ */
+export function withFieldRefsClassFactory<T extends new (data?: any) => any>(
+  BaseClass: T
+): new (data?: WithFieldRefs<ConstructorParameters<T>[0]>) => InstanceType<T> {
+  return class extends (BaseClass as any) {
+    constructor(data?: WithFieldRefs<ConstructorParameters<T>[0]>) {
+      // Process the data to resolve FieldRef instances
+      const processedData = processFieldRefs(data)
+      super(processedData)
+    }
+
+    // Override toJSON to ensure FieldRefs are properly serialized
+    toJSON() {
+      const json = super.toJSON()
+      return processFieldRefs(json)
+    }
+  } as any
+}
+
+/**
+ * Recursively process an object to resolve FieldRef instances to their string values
+ */
+function processFieldRefs(obj: any): any {
+  if (obj === null || obj === undefined) {
+    return obj
+  }
+
+  // If it's a FieldRef, return its string value
+  if (obj instanceof FieldRef) {
+    return obj.toString()
+  }
+
+  // If it's an array, process each element
+  if (Array.isArray(obj)) {
+    return obj.map(item => processFieldRefs(item))
+  }
+
+  // If it's an object, process each property
+  if (typeof obj === "object") {
+    const processed: any = {}
+    for (const key in obj) {
+      // if (obj.hasOwnProperty(key)) {
+      if (Object.hasOwn(obj, key)) {
+        processed[key] = processFieldRefs(obj[key])
+      }
+    }
+    return processed
+  }
+
+  // For primitive values, return as-is
+  return obj
+}

packages/sdk/src/utils/FieldRef.ts

@@ -0,0 +1,25 @@
+/**
+ * Encode string data to base64 for Kubernetes secret storage
+ * @param data - Object with string keys and values to encode
+ * @returns Object with base64-encoded values
+ */
+export const toSecretData = (data: Record<string, string>): Record<string, string> => {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(data)) {
+    result[key] = Buffer.from(value, "utf8").toString("base64")
+  }
+  return result
+}
+
+/**
+ * Decode base64 data from Kubernetes secret storage
+ * @param data - Object with string keys and base64-encoded values
+ * @returns Object with decoded string values
+ */
+export const fromSecretData = (data: Record<string, string>): Record<string, string> => {
+  const result: Record<string, string> = {}
+  for (const [key, value] of Object.entries(data)) {
+    result[key] = Buffer.from(value, "base64").toString("utf8")
+  }
+  return result
+}