katanakit-js 6.2.0 → 6.6.1

package/dist/adapters/insforge/insforge.service.js

@@ -2,8 +2,6 @@ import { createAdminClient, createClient } from "@insforge/sdk";
 import { useSplitConfig } from "../../core/services/utils.service.js";
 import { useValidate } from "../../core/services/validation.service.js";
 import { IfBucketSchema, IfConfigSchema, IfInsertRowsSchema, IfInvokeOptionsSchema, IfListOptionsSchema, IfRpcCallSchema, IfStorageRefSchema, IfTableNameSchema, IfTableQuerySchema, IfUpdatePatchSchema, IfWriteQuerySchema, } from "../../schemas/insforge.schema.js";
-/** Module-level client. InsForge is the database fallback, not the default. */
-let client = null;
 /**
  * Maps an SDK error (InsForgeError or unknown throw) to the shared `ApiError`.
  *
@@ -105,7 +103,370 @@ function scopedDatabase(database, schema) {
     return database;
 }
 /**
- * Registers the InsForge client and returns your methods alongside it — the
+ * InsForgeService - Singleton para el cliente InsForge (fallback de base de datos).
+ *
+ * Aplica el patrón Singleton: una única instancia mantiene el
+ * {@link InsForgeClient} y centraliza las operaciones de tabla, RPC,
+ * storage y edge functions, devolviendo siempre Safe Results.
+ *
+ * @example
+ * ```ts
+ * const insforge = InsForgeService.getInstance();
+ * insforge.useInit({ baseUrl: "https://app.insforge.app", anonKey: "…" });
+ * const result = await insforge.useSelect({ table: "posts" });
+ * ```
+ */
+export class InsForgeService {
+    static instance;
+    /** InsForge client. InsForge is the database fallback, not the default. */
+    client = null;
+    /**
+     * Constructor privado - enforce singleton.
+     */
+    constructor() { }
+    /**
+     * Obtiene la instancia única del InsForgeService (Singleton).
+     *
+     * @returns La instancia única de {@link InsForgeService}.
+     */
+    static getInstance() {
+        if (!InsForgeService.instance) {
+            InsForgeService.instance = new InsForgeService();
+        }
+        return InsForgeService.instance;
+    }
+    /**
+     * Registers the InsForge client. Call once per app. Prefer `apiKey`
+     * (server-only, admin) or `anonKey` (browser-safe) depending on the runtime.
+     *
+     * @param config - Backend URL + credentials + optional schema.
+     * @throws {Error} If the config fails validation.
+     *
+     * @example
+     * ```ts
+     * InsForgeService.getInstance().useInit({ baseUrl: "https://app.insforge.app", anonKey: "…" });
+     * ```
+     */
+    useInit(config) {
+        const parsed = useValidate(IfConfigSchema, config);
+        if (!parsed.ok) {
+            throw new Error(`[InsForge] Invalid config: ${parsed.error.message}`);
+        }
+        const { baseUrl, anonKey, apiKey, accessToken, schema } = parsed.data;
+        this.client = apiKey
+            ? createAdminClient({ baseUrl, apiKey })
+            : createClient({
+                baseUrl,
+                ...(anonKey !== undefined ? { anonKey } : {}),
+                ...(accessToken !== undefined ? { accessToken } : {}),
+                ...(schema !== undefined ? { db: { schema } } : {}),
+            });
+    }
+    /**
+     * Returns the initialized client (or `null` before `useInit`).
+     * Exposed for advanced use - the wrappers cover the supported surface.
+     *
+     * @returns The InsForge client or `null`.
+     */
+    useGetClient() {
+        return this.client;
+    }
+    /**
+     * Reads rows from a table with equality filters, ordering and pagination.
+     *
+     * @param query - Table, columns, filters, order, limit and offset.
+     * @returns Safe Result with the rows.
+     */
+    async useSelect(query) {
+        const parsed = useValidate(IfTableQuerySchema, query);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const database = scopedDatabase(db.database, parsed.data.schema);
+            let builder = database.from(parsed.data.table).select(parsed.data.columns ?? "*");
+            builder = applyFilters(builder, parsed.data.filters);
+            if (parsed.data.order) {
+                builder = builder.order(parsed.data.order.column, {
+                    ascending: parsed.data.order.ascending ?? true,
+                });
+            }
+            if (parsed.data.limit !== undefined)
+                builder = builder.limit(parsed.data.limit);
+            if (parsed.data.offset !== undefined) {
+                const from = parsed.data.offset;
+                builder = builder.range(from, from + (parsed.data.limit ?? 100) - 1);
+            }
+            const outcome = await builder;
+            if (outcome.error)
+                throw outcome.error;
+            return (outcome.data ?? []);
+        });
+    }
+    /**
+     * Inserts one or more rows and returns the created rows.
+     *
+     * @param table - Table name.
+     * @param rows - Rows to insert (at least one).
+     * @param schema - Optional schema override.
+     * @returns Safe Result with the inserted rows.
+     */
+    async useInsert(table, rows, schema) {
+        const tableParsed = useValidate(IfTableNameSchema, table);
+        if (!tableParsed.ok)
+            return invalidInput(tableParsed);
+        const rowsParsed = useValidate(IfInsertRowsSchema, rows);
+        if (!rowsParsed.ok)
+            return invalidInput(rowsParsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const database = scopedDatabase(db.database, schema);
+            const builder = database.from(tableParsed.data).insert(rowsParsed.data);
+            const outcome = await builder.select("*");
+            if (outcome.error)
+                throw outcome.error;
+            return (outcome.data ?? []);
+        }, 201);
+    }
+    /**
+     * Updates rows matching the filters and returns the updated rows.
+     * Filters are REQUIRED - mass updates are refused at validation time.
+     *
+     * @param query - Table + mandatory filters (+ optional schema).
+     * @param patch - Column patch (must not be empty).
+     * @returns Safe Result with the updated rows.
+     */
+    async useUpdate(query, patch) {
+        const queryParsed = useValidate(IfWriteQuerySchema, query);
+        if (!queryParsed.ok)
+            return invalidInput(queryParsed);
+        const patchParsed = useValidate(IfUpdatePatchSchema, patch);
+        if (!patchParsed.ok)
+            return invalidInput(patchParsed);
+        if (Object.keys(patchParsed.data).length === 0) {
+            return {
+                data: null,
+                error: { message: "Validation Error: patch must not be empty", status: 400 },
+                url: "",
+                status: 400,
+                ok: false,
+            };
+        }
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const database = scopedDatabase(db.database, queryParsed.data.schema);
+            const updateBuilder = database.from(queryParsed.data.table).update(patchParsed.data);
+            const filtered = applyFilters(updateBuilder, queryParsed.data.filters);
+            const outcome = await filtered.select("*");
+            if (outcome.error)
+                throw outcome.error;
+            return (outcome.data ?? []);
+        });
+    }
+    /**
+     * Deletes rows matching the filters and returns the deleted rows.
+     * Filters are REQUIRED - mass deletes are refused at validation time.
+     *
+     * @param query - Table + mandatory filters (+ optional schema).
+     * @returns Safe Result with the deleted rows.
+     */
+    async useDelete(query) {
+        const parsed = useValidate(IfWriteQuerySchema, query);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const database = scopedDatabase(db.database, parsed.data.schema);
+            const deleteBuilder = database.from(parsed.data.table).delete();
+            const filtered = applyFilters(deleteBuilder, parsed.data.filters);
+            const outcome = await filtered.select("*");
+            if (outcome.error)
+                throw outcome.error;
+            return (outcome.data ?? []);
+        });
+    }
+    /**
+     * Calls a Postgres function (RPC).
+     *
+     * @param call - Function name, params and optional schema.
+     * @returns Safe Result with the function output.
+     */
+    async useRpc(call) {
+        const parsed = useValidate(IfRpcCallSchema, call);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const database = scopedDatabase(db.database, parsed.data.schema);
+            const outcome = await database.rpc(parsed.data.name, parsed.data.params ?? {});
+            if (outcome.error)
+                throw outcome.error;
+            return outcome.data;
+        });
+    }
+    /**
+     * Uploads a file to a bucket (standard PUT semantics: same key replaces).
+     *
+     * @param ref - Bucket + object key.
+     * @param file - File or Blob to upload.
+     * @returns Safe Result with the stored file metadata.
+     */
+    async useUpload(ref, file) {
+        const parsed = useValidate(IfStorageRefSchema, ref);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const { data, error } = await db.storage.from(parsed.data.bucket).upload(parsed.data.path, file);
+            if (error)
+                throw error;
+            return (data ?? {});
+        });
+    }
+    /**
+     * Downloads a file from a bucket.
+     *
+     * @param ref - Bucket + object key.
+     * @returns Safe Result with the file as a Blob.
+     */
+    async useDownload(ref) {
+        const parsed = useValidate(IfStorageRefSchema, ref);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        const result = await run(async () => {
+            const { data, error } = await db.storage.from(parsed.data.bucket).download(parsed.data.path);
+            if (error)
+                throw error;
+            return data;
+        });
+        if (!result.ok)
+            return result;
+        if (!result.data) {
+            return {
+                data: null,
+                error: { message: "InsForge Error: object not found", status: 404 },
+                url: "",
+                status: 404,
+                ok: false,
+            };
+        }
+        return { data: result.data, error: null, url: "", status: 200, ok: true };
+    }
+    /**
+     * Removes a file from a bucket.
+     *
+     * @param ref - Bucket + object key.
+     * @returns Safe Result with the deletion response.
+     */
+    async useRemove(ref) {
+        const parsed = useValidate(IfStorageRefSchema, ref);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const { data, error } = await db.storage.from(parsed.data.bucket).remove(parsed.data.path);
+            if (error)
+                throw error;
+            return (data ?? {});
+        });
+    }
+    /**
+     * Lists objects in a bucket.
+     *
+     * @param bucket - Bucket name.
+     * @param options - Prefix, search, limit and offset.
+     * @returns Safe Result with the listing.
+     */
+    async useListObjects(bucket, options) {
+        const bucketParsed = useValidate(IfBucketSchema, bucket);
+        if (!bucketParsed.ok)
+            return invalidInput(bucketParsed);
+        const optionsParsed = useValidate(IfListOptionsSchema, options ?? {});
+        if (!optionsParsed.ok)
+            return invalidInput(optionsParsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const { data, error } = await db.storage.from(bucketParsed.data).list(optionsParsed.data);
+            if (error)
+                throw error;
+            return (data ?? {});
+        });
+    }
+    /**
+     * Builds the public URL for an object in a public bucket (no network call).
+     *
+     * @param ref - Bucket + object key.
+     * @returns Safe Result with `{ publicUrl }`.
+     */
+    useGetPublicUrl(ref) {
+        const parsed = useValidate(IfStorageRefSchema, ref);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const { data, error } = this.client.storage
+            .from(parsed.data.bucket)
+            .getPublicUrl(parsed.data.path);
+        if (error)
+            return fail(error);
+        if (!data) {
+            return {
+                data: null,
+                error: { message: "InsForge Error: public URL unavailable", status: 404 },
+                url: "",
+                status: 404,
+                ok: false,
+            };
+        }
+        return { data, error: null, url: "", status: 200, ok: true };
+    }
+    /**
+     * Invokes an edge function.
+     *
+     * @param options - Function slug + optional JSON body.
+     * @returns Safe Result with the function response.
+     */
+    async useInvokeFunction(options) {
+        const parsed = useValidate(IfInvokeOptionsSchema, options);
+        if (!parsed.ok)
+            return invalidInput(parsed);
+        if (!this.client)
+            return notConfigured();
+        const db = this.client;
+        return run(async () => {
+            const { data, error } = await db.functions.invoke(parsed.data.name, {
+                body: parsed.data.body,
+            });
+            if (error)
+                throw error;
+            return data;
+        });
+    }
+}
+/* -------------------------------------------------------------------------- */
+/* Initialization                                                             */
+/* -------------------------------------------------------------------------- */
+/**
+ * Registers the InsForge client and returns your methods alongside it - the
  * config-file entry point. One call is the whole setup: no separate
  * `useInitInsforge(...)` step.
  *
@@ -155,29 +516,20 @@ export function defineInsforgeConfig(input) {
  * ```
  */
 export function useInitInsforge(config) {
-    const parsed = useValidate(IfConfigSchema, config);
-    if (!parsed.ok) {
-        throw new Error(`[InsForge] Invalid config: ${parsed.error.message}`);
-    }
-    const { baseUrl, anonKey, apiKey, accessToken, schema } = parsed.data;
-    client = apiKey
-        ? createAdminClient({ baseUrl, apiKey })
-        : createClient({
-            baseUrl,
-            ...(anonKey !== undefined ? { anonKey } : {}),
-            ...(accessToken !== undefined ? { accessToken } : {}),
-            ...(schema !== undefined ? { db: { schema } } : {}),
-        });
+    InsForgeService.getInstance().useInit(config);
 }
 /**
  * Returns the initialized client (or `null` before `useInitInsforge`).
- * Exposed for advanced use — the wrappers cover the supported surface.
+ * Exposed for advanced use - the wrappers cover the supported surface.
  *
  * @returns The InsForge client or `null`.
  */
 export function useGetInsforgeClient() {
-    return client;
+    return InsForgeService.getInstance().useGetClient();
 }
+/* -------------------------------------------------------------------------- */
+/* Wrappers (backward compatibility)                                          */
+/* -------------------------------------------------------------------------- */
 /**
  * Reads rows from a table with equality filters, ordering and pagination.
  *
@@ -190,32 +542,7 @@ export function useGetInsforgeClient() {
  * ```
  */
 export async function useIfSelect(query) {
-    const parsed = useValidate(IfTableQuerySchema, query);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const database = scopedDatabase(db.database, parsed.data.schema);
-        let builder = database.from(parsed.data.table).select(parsed.data.columns ?? "*");
-        builder = applyFilters(builder, parsed.data.filters);
-        if (parsed.data.order) {
-            builder = builder.order(parsed.data.order.column, {
-                ascending: parsed.data.order.ascending ?? true,
-            });
-        }
-        if (parsed.data.limit !== undefined)
-            builder = builder.limit(parsed.data.limit);
-        if (parsed.data.offset !== undefined) {
-            const from = parsed.data.offset;
-            builder = builder.range(from, from + (parsed.data.limit ?? 100) - 1);
-        }
-        const outcome = await builder;
-        if (outcome.error)
-            throw outcome.error;
-        return (outcome.data ?? []);
-    });
+    return InsForgeService.getInstance().useSelect(query);
 }
 /**
  * Inserts one or more rows and returns the created rows.
@@ -226,84 +553,28 @@ export async function useIfSelect(query) {
  * @returns Safe Result with the inserted rows.
  */
 export async function useIfInsert(table, rows, schema) {
-    const tableParsed = useValidate(IfTableNameSchema, table);
-    if (!tableParsed.ok)
-        return invalidInput(tableParsed);
-    const rowsParsed = useValidate(IfInsertRowsSchema, rows);
-    if (!rowsParsed.ok)
-        return invalidInput(rowsParsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const database = scopedDatabase(db.database, schema);
-        const builder = database.from(tableParsed.data).insert(rowsParsed.data);
-        const outcome = await builder.select("*");
-        if (outcome.error)
-            throw outcome.error;
-        return (outcome.data ?? []);
-    }, 201);
+    return InsForgeService.getInstance().useInsert(table, rows, schema);
 }
 /**
  * Updates rows matching the filters and returns the updated rows.
- * Filters are REQUIRED — mass updates are refused at validation time.
+ * Filters are REQUIRED - mass updates are refused at validation time.
  *
  * @param query - Table + mandatory filters (+ optional schema).
  * @param patch - Column patch (must not be empty).
  * @returns Safe Result with the updated rows.
  */
 export async function useIfUpdate(query, patch) {
-    const queryParsed = useValidate(IfWriteQuerySchema, query);
-    if (!queryParsed.ok)
-        return invalidInput(queryParsed);
-    const patchParsed = useValidate(IfUpdatePatchSchema, patch);
-    if (!patchParsed.ok)
-        return invalidInput(patchParsed);
-    if (Object.keys(patchParsed.data).length === 0) {
-        return {
-            data: null,
-            error: { message: "Validation Error: patch must not be empty", status: 400 },
-            url: "",
-            status: 400,
-            ok: false,
-        };
-    }
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const database = scopedDatabase(db.database, queryParsed.data.schema);
-        const updateBuilder = database.from(queryParsed.data.table).update(patchParsed.data);
-        const filtered = applyFilters(updateBuilder, queryParsed.data.filters);
-        const outcome = await filtered.select("*");
-        if (outcome.error)
-            throw outcome.error;
-        return (outcome.data ?? []);
-    });
+    return InsForgeService.getInstance().useUpdate(query, patch);
 }
 /**
  * Deletes rows matching the filters and returns the deleted rows.
- * Filters are REQUIRED — mass deletes are refused at validation time.
+ * Filters are REQUIRED - mass deletes are refused at validation time.
  *
  * @param query - Table + mandatory filters (+ optional schema).
  * @returns Safe Result with the deleted rows.
  */
 export async function useIfDelete(query) {
-    const parsed = useValidate(IfWriteQuerySchema, query);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const database = scopedDatabase(db.database, parsed.data.schema);
-        const deleteBuilder = database.from(parsed.data.table).delete();
-        const filtered = applyFilters(deleteBuilder, parsed.data.filters);
-        const outcome = await filtered.select("*");
-        if (outcome.error)
-            throw outcome.error;
-        return (outcome.data ?? []);
-    });
+    return InsForgeService.getInstance().useDelete(query);
 }
 /**
  * Calls a Postgres function (RPC).
@@ -312,19 +583,7 @@ export async function useIfDelete(query) {
  * @returns Safe Result with the function output.
  */
 export async function useIfRpc(call) {
-    const parsed = useValidate(IfRpcCallSchema, call);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const database = scopedDatabase(db.database, parsed.data.schema);
-        const outcome = await database.rpc(parsed.data.name, parsed.data.params ?? {});
-        if (outcome.error)
-            throw outcome.error;
-        return outcome.data;
-    });
+    return InsForgeService.getInstance().useRpc(call);
 }
 /**
  * Uploads a file to a bucket (standard PUT semantics: same key replaces).
@@ -334,18 +593,7 @@ export async function useIfRpc(call) {
  * @returns Safe Result with the stored file metadata.
  */
 export async function useIfUpload(ref, file) {
-    const parsed = useValidate(IfStorageRefSchema, ref);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const { data, error } = await db.storage.from(parsed.data.bucket).upload(parsed.data.path, file);
-        if (error)
-            throw error;
-        return (data ?? {});
-    });
+    return InsForgeService.getInstance().useUpload(ref, file);
 }
 /**
  * Downloads a file from a bucket.
@@ -354,30 +602,7 @@ export async function useIfUpload(ref, file) {
  * @returns Safe Result with the file as a Blob.
  */
 export async function useIfDownload(ref) {
-    const parsed = useValidate(IfStorageRefSchema, ref);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    const result = await run(async () => {
-        const { data, error } = await db.storage.from(parsed.data.bucket).download(parsed.data.path);
-        if (error)
-            throw error;
-        return data;
-    });
-    if (!result.ok)
-        return result;
-    if (!result.data) {
-        return {
-            data: null,
-            error: { message: "InsForge Error: object not found", status: 404 },
-            url: "",
-            status: 404,
-            ok: false,
-        };
-    }
-    return { data: result.data, error: null, url: "", status: 200, ok: true };
+    return InsForgeService.getInstance().useDownload(ref);
 }
 /**
  * Removes a file from a bucket.
@@ -386,18 +611,7 @@ export async function useIfDownload(ref) {
  * @returns Safe Result with the deletion response.
  */
 export async function useIfRemove(ref) {
-    const parsed = useValidate(IfStorageRefSchema, ref);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const { data, error } = await db.storage.from(parsed.data.bucket).remove(parsed.data.path);
-        if (error)
-            throw error;
-        return (data ?? {});
-    });
+    return InsForgeService.getInstance().useRemove(ref);
 }
 /**
  * Lists objects in a bucket.
@@ -407,21 +621,7 @@ export async function useIfRemove(ref) {
  * @returns Safe Result with the listing.
  */
 export async function useIfListObjects(bucket, options) {
-    const bucketParsed = useValidate(IfBucketSchema, bucket);
-    if (!bucketParsed.ok)
-        return invalidInput(bucketParsed);
-    const optionsParsed = useValidate(IfListOptionsSchema, options ?? {});
-    if (!optionsParsed.ok)
-        return invalidInput(optionsParsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const { data, error } = await db.storage.from(bucketParsed.data).list(optionsParsed.data);
-        if (error)
-            throw error;
-        return (data ?? {});
-    });
+    return InsForgeService.getInstance().useListObjects(bucket, options);
 }
 /**
  * Builds the public URL for an object in a public bucket (no network call).
@@ -430,24 +630,7 @@ export async function useIfListObjects(bucket, options) {
  * @returns Safe Result with `{ publicUrl }`.
  */
 export function useIfGetPublicUrl(ref) {
-    const parsed = useValidate(IfStorageRefSchema, ref);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const { data, error } = client.storage.from(parsed.data.bucket).getPublicUrl(parsed.data.path);
-    if (error)
-        return fail(error);
-    if (!data) {
-        return {
-            data: null,
-            error: { message: "InsForge Error: public URL unavailable", status: 404 },
-            url: "",
-            status: 404,
-            ok: false,
-        };
-    }
-    return { data, error: null, url: "", status: 200, ok: true };
+    return InsForgeService.getInstance().useGetPublicUrl(ref);
 }
 /**
  * Invokes an edge function.
@@ -456,19 +639,6 @@ export function useIfGetPublicUrl(ref) {
  * @returns Safe Result with the function response.
  */
 export async function useIfInvokeFunction(options) {
-    const parsed = useValidate(IfInvokeOptionsSchema, options);
-    if (!parsed.ok)
-        return invalidInput(parsed);
-    if (!client)
-        return notConfigured();
-    const db = client;
-    return run(async () => {
-        const { data, error } = await db.functions.invoke(parsed.data.name, {
-            body: parsed.data.body,
-        });
-        if (error)
-            throw error;
-        return data;
-    });
+    return InsForgeService.getInstance().useInvokeFunction(options);
 }
 //# sourceMappingURL=insforge.service.js.map