0x1998 - MANAGER

Düzenlenen Dosya: index.node.cjs.js

'use strict';

Object.defineProperty(exports, '__esModule', { value: true });

var util = require('@firebase/util');
var logger$1 = require('@firebase/logger');
var app = require('@firebase/app');
var component = require('@firebase/component');

const name = "@firebase/data-connect";
const version = "0.4.0";

/**
 * @license
 * Copyright 2025 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
const GLOBAL_ID_KEY = '_id';
const OBJECT_LISTS_KEY = '_objectLists';
const REFERENCES_KEY = '_references';
const SCALARS_KEY = '_scalars';
const ENTITY_DATA_KEYS_KEY = '_entity_data_keys';
class EntityNode {
    constructor() {
        this.scalars = {};
        this.references = {};
        this.objectLists = {};
        this.entityDataKeys = new Set();
    }
    async loadData(queryId, values, entityIds, acc, cacheProvider) {
        if (values === undefined) {
            return;
        }
        if (typeof values !== 'object' || Array.isArray(values)) {
            throw new DataConnectError(Code.INVALID_ARGUMENT, 'EntityNode initialized with non-object value');
        }
        if (values === null) {
            return;
        }
        if (typeof values === 'object' &&
            entityIds &&
            entityIds[GLOBAL_ID_KEY] &&
            typeof entityIds[GLOBAL_ID_KEY] === 'string') {
            this.globalId = entityIds[GLOBAL_ID_KEY];
            this.entityData = await cacheProvider.getEntityData(this.globalId);
        }
        for (const key in values) {
            if (values.hasOwnProperty(key)) {
                if (typeof values[key] === 'object') {
                    if (Array.isArray(values[key])) {
                        const ids = entityIds && entityIds[key];
                        const objArray = [];
                        const scalarArray = [];
                        for (const [index, value] of values[key].entries()) {
                            if (typeof value === 'object') {
                                if (Array.isArray(value)) ;
                                else {
                                    const entityNode = new EntityNode();
                                    await entityNode.loadData(queryId, value, ids && ids[index], acc, cacheProvider);
                                    objArray.push(entityNode);
                                }
                            }
                            else {
                                scalarArray.push(value);
                            }
                        }
                        if (scalarArray.length > 0 && objArray.length > 0) {
                            this.scalars[key] = values[key];
                        }
                        else if (scalarArray.length > 0) {
                            if (this.entityData) {
                                const impactedRefs = this.entityData.updateServerValue(key, scalarArray, queryId);
                                this.entityDataKeys.add(key);
                                acc.add(impactedRefs);
                            }
                            else {
                                this.scalars[key] = scalarArray;
                            }
                        }
                        else if (objArray.length > 0) {
                            this.objectLists[key] = objArray;
                        }
                        else {
                            this.scalars[key] = [];
                        }
                    }
                    else {
                        if (values[key] === null) {
                            this.scalars[key] = null;
                            continue;
                        }
                        const entityNode = new EntityNode();
                        // TODO: Load Data might need to be pushed into ResultTreeProcessor instead.
                        await entityNode.loadData(queryId, values[key], entityIds && entityIds[key], acc, cacheProvider);
                        this.references[key] = entityNode;
                    }
                }
                else {
                    if (this.entityData) {
                        const impactedRefs = this.entityData.updateServerValue(key, values[key], queryId);
                        this.entityDataKeys.add(key);
                        acc.add(impactedRefs);
                    }
                    else {
                        this.scalars[key] = values[key];
                    }
                }
            }
        }
        if (this.entityData) {
            await cacheProvider.updateEntityData(this.entityData);
        }
    }
    toJSON(mode) {
        const resultObject = {};
        if (mode === EncodingMode.hydrated) {
            if (this.entityData) {
                for (const key of this.entityDataKeys) {
                    resultObject[key] = this.entityData.getServerValue(key);
                }
            }
            if (this.scalars) {
                Object.assign(resultObject, this.scalars);
            }
            if (this.references) {
                for (const key in this.references) {
                    if (this.references.hasOwnProperty(key)) {
                        resultObject[key] = this.references[key].toJSON(mode);
                    }
                }
            }
            if (this.objectLists) {
                for (const key in this.objectLists) {
                    if (this.objectLists.hasOwnProperty(key)) {
                        resultObject[key] = this.objectLists[key].map(obj => obj.toJSON(mode));
                    }
                }
            }
            return resultObject;
        }
        else {
            // Get JSON representation of dehydrated list
            if (this.entityData) {
                resultObject[GLOBAL_ID_KEY] = this.entityData.globalID;
            }
            resultObject[ENTITY_DATA_KEYS_KEY] = Array.from(this.entityDataKeys);
            if (this.scalars) {
                resultObject[SCALARS_KEY] = this.scalars;
            }
            if (this.references) {
                const references = {};
                for (const key in this.references) {
                    if (this.references.hasOwnProperty(key)) {
                        references[key] = this.references[key].toJSON(mode);
                    }
                }
                resultObject[REFERENCES_KEY] = references;
            }
            if (this.objectLists) {
                const objectLists = {};
                for (const key in this.objectLists) {
                    if (this.objectLists.hasOwnProperty(key)) {
                        objectLists[key] = this.objectLists[key].map(obj => obj.toJSON(mode));
                    }
                }
                resultObject[OBJECT_LISTS_KEY] = objectLists;
            }
        }
        return resultObject;
    }
    static fromJson(obj) {
        const sdo = new EntityNode();
        if (obj.backingData) {
            sdo.entityData = EntityDataObject.fromJSON(obj.backingData);
        }
        sdo.globalId = obj.globalID;
        sdo.scalars = obj.scalars;
        if (obj.references) {
            const references = {};
            for (const key in obj.references) {
                if (obj.references.hasOwnProperty(key)) {
                    references[key] = EntityNode.fromJson(obj.references[key]);
                }
            }
            sdo.references = references;
        }
        if (obj.objectLists) {
            const objectLists = {};
            for (const key in obj.objectLists) {
                if (obj.objectLists.hasOwnProperty(key)) {
                    objectLists[key] = obj.objectLists[key].map(obj => EntityNode.fromJson(obj));
                }
            }
            sdo.objectLists = objectLists;
        }
        return sdo;
    }
}
// Helpful for storing in persistent cache, which is not available yet.
var EncodingMode;
(function (EncodingMode) {
    EncodingMode[EncodingMode["hydrated"] = 0] = "hydrated";
    EncodingMode[EncodingMode["dehydrated"] = 1] = "dehydrated";
})(EncodingMode || (EncodingMode = {}));

/**
 * @license
 * Copyright 2026 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
function parseEntityIds(result) {
    // Iterate through extensions.dataConnect
    const dataConnectExtensions = result.extensions?.dataConnect;
    const dataCopy = Object.assign(result);
    if (!dataConnectExtensions) {
        return dataCopy;
    }
    const ret = {};
    for (const extension of dataConnectExtensions) {
        const { path } = extension;
        populatePath(path, ret, extension);
    }
    return ret;
}
// mutates the object to update the path
function populatePath(path, toUpdate, extension) {
    let curObj = toUpdate;
    for (const slice of path) {
        if (typeof curObj[slice] !== 'object') {
            curObj[slice] = {};
        }
        curObj = curObj[slice];
    }
    if ('entityId' in extension && extension.entityId) {
        curObj['_id'] = extension.entityId;
    }
    else if ('entityIds' in extension) {
        const entityArr = extension.entityIds;
        for (let i = 0; i < entityArr.length; i++) {
            const entityId = entityArr[i];
            if (typeof curObj[i] === 'undefined') {
                curObj[i] = {};
            }
            curObj[i]._id = entityId;
        }
    }
}

/**
 * @license
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
function getRefSerializer(queryRef, data, source, fetchTime) {
    return function toJSON() {
        return {
            data,
            refInfo: {
                name: queryRef.name,
                variables: queryRef.variables,
                connectorConfig: {
                    projectId: queryRef.dataConnect.app.options.projectId,
                    ...queryRef.dataConnect.getSettings()
                }
            },
            fetchTime,
            source
        };
    };
}
class QueryManager {
    async preferCacheResults(queryRef, allowStale = false) {
        let cacheResult;
        try {
            cacheResult = await this.fetchCacheResults(queryRef, allowStale);
        }
        catch (e) {
            // Ignore the error and try to fetch from the server.
        }
        if (cacheResult) {
            return cacheResult;
        }
        return this.fetchServerResults(queryRef);
    }
    constructor(transport, dc, cache) {
        this.transport = transport;
        this.dc = dc;
        this.cache = cache;
        this.callbacks = new Map();
        this.subscriptionCache = new Map();
        this.queue = [];
    }
    async waitForQueuedWrites() {
        for (const promise of this.queue) {
            await promise;
        }
        this.queue = [];
    }
    updateSSR(updatedData) {
        this.queue.push(this.updateCache(updatedData).then(async (result) => this.publishCacheResultsToSubscribers(result, updatedData.fetchTime)));
    }
    async updateCache(result, extensions) {
        await this.waitForQueuedWrites();
        if (this.cache) {
            const entityIds = parseEntityIds(result);
            const updatedMaxAge = getMaxAgeFromExtensions(extensions);
            if (updatedMaxAge !== undefined) {
                this.cache.cacheSettings.maxAgeSeconds = updatedMaxAge;
            }
            return this.cache.update(encoderImpl({
                name: result.ref.name,
                variables: result.ref.variables,
                refType: QUERY_STR
            }), result.data, entityIds);
        }
        else {
            const key = encoderImpl({
                name: result.ref.name,
                variables: result.ref.variables,
                refType: QUERY_STR
            });
            this.subscriptionCache.set(key, result);
            return [key];
        }
    }
    addSubscription(queryRef, onResultCallback, onCompleteCallback, onErrorCallback, initialCache) {
        const key = encoderImpl({
            name: queryRef.name,
            variables: queryRef.variables,
            refType: QUERY_STR
        });
        const unsubscribe = () => {
            if (this.callbacks.has(key)) {
                const callbackList = this.callbacks.get(key);
                this.callbacks.set(key, callbackList.filter(callback => callback !== subscription));
                onCompleteCallback?.();
            }
        };
        const subscription = {
            userCallback: onResultCallback,
            errCallback: onErrorCallback,
            unsubscribe
        };
        if (initialCache) {
            this.updateSSR(initialCache);
        }
        const promise = this.preferCacheResults(queryRef, /*allowStale=*/ true);
        // We want to ignore the error and let subscriptions handle it
        promise.then(undefined, err => { });
        if (!this.callbacks.has(key)) {
            this.callbacks.set(key, []);
        }
        this.callbacks
            .get(key)
            .push(subscription);
        return unsubscribe;
    }
    async fetchServerResults(queryRef) {
        await this.waitForQueuedWrites();
        const key = encoderImpl({
            name: queryRef.name,
            variables: queryRef.variables,
            refType: QUERY_STR
        });
        try {
            const result = await this.transport.invokeQuery(queryRef.name, queryRef.variables);
            const fetchTime = Date.now().toString();
            const originalExtensions = result.extensions;
            const queryResult = {
                ...result,
                ref: queryRef,
                source: SOURCE_SERVER,
                fetchTime,
                data: result.data,
                extensions: getDataConnectExtensionsWithoutMaxAge(originalExtensions),
                toJSON: getRefSerializer(queryRef, result.data, SOURCE_SERVER, fetchTime)
            };
            let updatedKeys = [];
            updatedKeys = await this.updateCache(queryResult, originalExtensions?.dataConnect);
            this.publishDataToSubscribers(key, queryResult);
            if (this.cache) {
                await this.publishCacheResultsToSubscribers(updatedKeys, fetchTime);
            }
            else {
                this.subscriptionCache.set(key, queryResult);
            }
            return queryResult;
        }
        catch (e) {
            this.publishErrorToSubscribers(key, e);
            throw e;
        }
    }
    async fetchCacheResults(queryRef, allowStale = false) {
        await this.waitForQueuedWrites();
        let result;
        if (!this.cache) {
            result = await this.getFromSubscriberCache(queryRef);
        }
        else {
            result = await this.getFromResultTreeCache(queryRef, allowStale);
        }
        if (!result) {
            throw new DataConnectError(Code.OTHER, 'No cache entry found for query: ' + queryRef.name);
        }
        const fetchTime = Date.now().toString();
        const queryResult = {
            ...result,
            ref: queryRef,
            source: SOURCE_CACHE,
            fetchTime,
            data: result.data,
            extensions: result.extensions,
            toJSON: getRefSerializer(queryRef, result.data, SOURCE_CACHE, fetchTime)
        };
        if (this.cache) {
            const key = encoderImpl({
                name: queryRef.name,
                variables: queryRef.variables,
                refType: QUERY_STR
            });
            await this.publishCacheResultsToSubscribers([key], fetchTime);
        }
        else {
            const key = encoderImpl({
                name: queryRef.name,
                variables: queryRef.variables,
                refType: QUERY_STR
            });
            this.subscriptionCache.set(key, queryResult);
            this.publishDataToSubscribers(key, queryResult);
        }
        return queryResult;
    }
    publishErrorToSubscribers(key, err) {
        this.callbacks.get(key)?.forEach(subscription => {
            if (subscription.errCallback) {
                subscription.errCallback(err);
            }
        });
    }
    async getFromResultTreeCache(queryRef, allowStale = false) {
        const key = encoderImpl({
            name: queryRef.name,
            variables: queryRef.variables,
            refType: QUERY_STR
        });
        if (!this.cache || !(await this.cache.containsResultTree(key))) {
            return null;
        }
        const cacheResult = (await this.cache.getResultJSON(key));
        const resultTree = await this.cache.getResultTree(key);
        if (!allowStale && resultTree.isStale()) {
            return null;
        }
        const result = {
            source: SOURCE_CACHE,
            ref: queryRef,
            data: cacheResult,
            toJSON: getRefSerializer(queryRef, cacheResult, SOURCE_CACHE, resultTree.cachedAt.toString()),
            fetchTime: resultTree.cachedAt.toString()
        };
        (await this.cache.getResultTree(key)).updateAccessed();
        return result;
    }
    async getFromSubscriberCache(queryRef) {
        const key = encoderImpl({
            name: queryRef.name,
            variables: queryRef.variables,
            refType: QUERY_STR
        });
        if (!this.subscriptionCache.has(key)) {
            return;
        }
        const result = this.subscriptionCache.get(key);
        result.source = SOURCE_CACHE;
        result.toJSON = getRefSerializer(result.ref, result.data, SOURCE_CACHE, result.fetchTime);
        return result;
    }
    publishDataToSubscribers(key, queryResult) {
        if (!this.callbacks.has(key)) {
            return;
        }
        const subscribers = this.callbacks.get(key);
        subscribers.forEach(callback => {
            callback.userCallback(queryResult);
        });
    }
    async publishCacheResultsToSubscribers(impactedQueries, fetchTime) {
        if (!this.cache) {
            return;
        }
        for (const query of impactedQueries) {
            const callbacks = this.callbacks.get(query);
            if (!callbacks) {
                continue;
            }
            const newJson = (await this.cache.getResultTree(query))
                .getRootStub()
                .toJSON(EncodingMode.hydrated);
            const { name, variables } = decoderImpl(query);
            const queryRef = {
                dataConnect: this.dc,
                refType: QUERY_STR,
                name,
                variables
            };
            this.publishDataToSubscribers(query, {
                data: newJson,
                fetchTime,
                ref: queryRef,
                source: SOURCE_CACHE,
                toJSON: getRefSerializer(queryRef, newJson, SOURCE_CACHE, fetchTime)
            });
        }
    }
    enableEmulator(host, port) {
        this.transport.useEmulator(host, port);
    }
}
function getMaxAgeFromExtensions(extensions) {
    if (!extensions) {
        return;
    }
    for (const extension of extensions) {
        if ('maxAge' in extension &&
            extension.maxAge !== undefined &&
            extension.maxAge !== null) {
            if (extension.maxAge.endsWith('s')) {
                return Number(extension.maxAge.substring(0, extension.maxAge.length - 1));
            }
        }
    }
}
function getDataConnectExtensionsWithoutMaxAge(extensions) {
    return {
        dataConnect: extensions.dataConnect?.filter(extension => 'entityId' in extension || 'entityIds' in extension)
    };
}

/**
 * @license
 * Copyright 2024 Google LLC
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
const FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR = 'FIREBASE_DATA_CONNECT_EMULATOR_HOST';
/**
 *
 * @param fullHost
 * @returns TransportOptions
 * @internal
 */
function parseOptions(fullHost) {
    const [protocol, hostName] = fullHost.split('://');
    const isSecure = protocol === 'https';
    const [host, portAsString] = hostName.split(':');
    const port = Number(portAsString);
    return { host, port, sslEnabled: isSecure };
}
/**
 * Class representing Firebase Data Connect
 */
class DataConnect {
    // @internal
    constructor(app, 
    // TODO(mtewani): Replace with _dataConnectOptions in the future
    dataConnectOptions, _authProvider, _appCheckProvider) {
        this.app = app;
        this.dataConnectOptions = dataConnectOptions;
        this._authProvider = _authProvider;
        this._appCheckProvider = _appCheckProvider;
        this.isEmulator = false;
        this._initialized = false;
        this._isUsingGeneratedSdk = false;
        this._callerSdkType = CallerSdkTypeEnum.Base;
        if (typeof process !== 'undefined' && process.env) {
            const host = process.env[FIREBASE_DATA_CONNECT_EMULATOR_HOST_VAR];
            if (host) {
                logDebug('Found custom host. Using emulator');
                this.isEmulator = true;
                this._transportOptions = parseOptions(host);
            }
        }
    }
    /**
     * @internal
     */
    getCache() {
        return this.cache;
    }
    // @internal
    _useGeneratedSdk() {
        if (!this._isUsingGeneratedSdk) {
            this._isUsingGeneratedSdk = true;
        }
    }
    _setCallerSdkType(callerSdkType) {
        this._callerSdkType = callerSdkType;
        if (this._initialized) {
            this._transport._setCallerSdkType(callerSdkType);
        }
    }
    _delete() {
        app._removeServiceInstance(this.app, 'data-connect', JSON.stringify(this.getSettings()));
        return Promise.resolve();
    }
    // @internal
    getSettings() {
        const copy = JSON.parse(JSON.stringify(this.dataConnectOptions));
        delete copy.projectId;
        return copy;
    }
    /**
     * @internal
     */
    setCacheSettings(cacheSettings) {
        this._cacheSettings = cacheSettings;
    }
    // @internal
    setInitialized() {
        if (this._initialized) {
            return;
        }
        if (this._transportClass === undefined) {
            logDebug('transportClass not provided. Defaulting to RESTTransport.');
            this._transportClass = RESTTransport;
        }
        this._authTokenProvider = new FirebaseAuthProvider(this.app.name, this.app.options, this._authProvider);
        const connectorConfig = {
            connector: this.dataConnectOptions.connector,
            service: this.dataConnectOptions.service,
            location: this.dataConnectOptions.location
        };
        if (this._cacheSettings) {
            this.cache = new DataConnectCache(this._authTokenProvider, this.app.options.projectId, connectorConfig, this._transportOptions?.host || PROD_HOST, this._cacheSettings);
        }
        if (this._appCheckProvider) {
            this._appCheckTokenProvider = new AppCheckTokenProvider(this.app, this._appCheckProvider);
        }
        this._transport = new this._transportClass(this.dataConnectOptions, this.app.options.apiKey, this.app.options.appId, this._authTokenProvider, this._appCheckTokenProvider, undefined, this._isUsingGeneratedSdk, this._callerSdkType);
        if (this._transportOptions) {
            this._transport.useEmulator(this._transportOptions.host, this._transportOptions.port, this._transportOptions.sslEnabled);
        }
        this._queryManager = new QueryManager(this._transport, this, this.cache);
        this._mutationManager = new MutationManager(this._transport);
        this._initialized = true;
    }
    // @internal
    enableEmulator(transportOptions) {
        if (this._transportOptions &&
            this._initialized &&
            !areTransportOptionsEqual(this._transportOptions, transportOptions)) {
            logError('enableEmulator called after initialization');
            throw new DataConnectError(Code.ALREADY_INITIALIZED, 'DataConnect instance already initialized!');
        }
        this._transportOptions = transportOptions;
        this.isEmulator = true;
    }
}
/**
 * @internal
 * @param transportOptions1
 * @param transportOptions2
 * @returns
 */
function areTransportOptionsEqual(transportOptions1, transportOptions2) {
    return (transportOptions1.host === transportOptions2.host &&
        transportOptions1.port === transportOptions2.port &&
        transportOptions1.sslEnabled === transportOptions2.sslEnabled);
}
/**
 * Connect to the DataConnect Emulator
 * @param dc Data Connect instance
 * @param host host of emulator server
 * @param port port of emulator server
 * @param sslEnabled use https
 */
function connectDataConnectEmulator(dc, host, port, sslEnabled = false) {
    // Workaround to get cookies in Firebase Studio
    if (util.isCloudWorkstation(host)) {
        void util.pingServer(`https://${host}${port ? `:${port}` : ''}`);
        util.updateEmulatorBanner('Data Connect', true);
    }
    dc.enableEmulator({ host, port, sslEnabled });
}
function getDataConnect(appOrConnectorConfig, settingsOrConnectorConfig, settings) {
    let app$1;
    let connectorConfig;
    let realSettings;
    if ('location' in appOrConnectorConfig) {
        connectorConfig = appOrConnectorConfig;
        app$1 = app.getApp();
        realSettings = settingsOrConnectorConfig;
    }
    else {
        app$1 = appOrConnectorConfig;
        connectorConfig = settingsOrConnectorConfig;
        realSettings = settings;
    }
    if (!app$1 || Object.keys(app$1).length === 0) {
        app$1 = app.getApp();
    }
    // Options to store in Firebase Component Provider.
    const serializedOptions = {
        ...connectorConfig,
        projectId: app$1.options.projectId
    };
    // We should sort the keys before initialization.
    const sortedSerialized = Object.fromEntries(Object.entries(serializedOptions).sort());
    const provider = app._getProvider(app$1, 'data-connect');
    const identifier = JSON.stringify(sortedSerialized);
    if (provider.isInitialized(identifier)) {
        const dcInstance = provider.getImmediate({ identifier });
        const options = provider.getOptions(identifier);
        const optionsValid = Object.keys(options).length > 0;
        if (optionsValid) {
            logDebug('Re-using cached instance');
            return dcInstance;
        }
    }
    validateDCOptions(connectorConfig);
    logDebug('Creating new DataConnect instance');
    // Initialize with options.
    const dataConnect = provider.initialize({
        instanceIdentifier: identifier,
        options: Object.fromEntries(Object.entries({
            ...sortedSerialized
        }).sort())
    });
    if (realSettings?.cacheSettings) {
        dataConnect.setCacheSettings(realSettings.cacheSettings);
    }
    return dataConnect;
}
/**
 *
 * @param dcOptions
 * @returns {void}
 * @internal
 */
function validateDCOptions(dcOptions) {
    const fields = ['connector', 'location', 'service'];
    if (!dcOptions) {
        throw new DataConnectError(Code.INVALID_ARGUMENT, 'DC Option Required');
    }
    fields.forEach(field => {
        if (dcOptions[field] === null ||
            dcOptions[field] === undefined) {
            throw new DataConnectError(Code.INVALID_ARGUMENT, `${field} Required`);
        }
    });
    return true;
}
/**
 * Delete DataConnect instance
 * @param dataConnect DataConnect instance
 * @returns
 */
function terminate(dataConnect) {
    return dataConnect._delete();
    // TODO(mtewani): Stop pending tasks
}
const StorageType = {
    MEMORY: 'MEMORY'
};
function makeMemoryCacheProvider() {
    return new MemoryStub();
}

exports.CallerSdkTypeEnum = CallerSdkTypeEnum;
exports.Code = Code;
exports.DataConnect = DataConnect;
exports.DataConnectError = DataConnectError;
exports.DataConnectOperationError = DataConnectOperationError;
exports.MUTATION_STR = MUTATION_STR;
exports.MutationManager = MutationManager;
exports.QUERY_STR = QUERY_STR;
exports.QueryFetchPolicy = QueryFetchPolicy;
exports.SOURCE_CACHE = SOURCE_CACHE;
exports.SOURCE_SERVER = SOURCE_SERVER;
exports.StorageType = StorageType;
exports.areTransportOptionsEqual = areTransportOptionsEqual;
exports.connectDataConnectEmulator = connectDataConnectEmulator;
exports.executeMutation = executeMutation;
exports.executeQuery = executeQuery;
exports.getDataConnect = getDataConnect;
exports.makeMemoryCacheProvider = makeMemoryCacheProvider;
exports.mutationRef = mutationRef;
exports.parseOptions = parseOptions;
exports.queryRef = queryRef;
exports.setLogLevel = setLogLevel;
exports.subscribe = subscribe;
exports.terminate = terminate;
exports.toQueryRef = toQueryRef;
exports.validateArgs = validateArgs;
exports.validateDCOptions = validateDCOptions;
//# sourceMappingURL=index.node.cjs.js.map

geri dön