@kinotic-ai/kinotic-cli 1.0.0

package/dist/internal/ProjectMigrationService.js

@@ -0,0 +1,99 @@
+import { Kinotic } from '@kinotic-ai/core';
+import { readdir, readFile, access } from 'fs/promises';
+import { join } from 'path';
+import { constants } from 'fs';
+/**
+ * Internal service for loading and applying migrations from the local filesystem.
+ * Looks for migration files in a 'migrations' folder in the project root.
+ */
+export class ProjectMigrationService {
+    migrationService;
+    logger;
+    constructor(logger) {
+        this.migrationService = Kinotic.migrations;
+        this.logger = logger;
+    }
+    /**
+     * Loads migration files from the migrations directory and applies any new ones.
+     *
+     * @param projectId the project identifier to apply migrations to
+     * @param migrationsDir the directory containing migration files (defaults to './migrations')
+     * @param verbose whether to enable verbose logging
+     */
+    async applyMigrations(projectId, migrationsDir = './migrations', verbose = false) {
+        // Check if migrations directory exists
+        try {
+            await access(migrationsDir, constants.F_OK);
+        }
+        catch {
+            this.logger.log('No migrations will be applied since no migrations directory found');
+            return;
+        }
+        // Get the last applied migration version
+        const lastAppliedVersion = await this.migrationService.getLastAppliedMigrationVersion(projectId);
+        // Load only the files that need to be applied
+        const migrationsToApply = await this.loadUnappliedMigrations(migrationsDir, lastAppliedVersion);
+        if (migrationsToApply.length === 0) {
+            this.logVerbose('No migration files found or all migrations already applied', verbose);
+            return;
+        }
+        this.logger.log(`Applying ${migrationsToApply.length} new migrations (starting from version ${lastAppliedVersion !== null ? lastAppliedVersion + 1 : 1})`);
+        // Apply the migrations
+        const migrationRequest = {
+            projectId,
+            migrations: migrationsToApply
+        };
+        const result = await this.migrationService.executeMigrations(migrationRequest);
+        if (result.success) {
+            this.logger.log(`Successfully applied ${result.migrationsProcessed} migrations`);
+        }
+        else {
+            throw new Error(`Migration failed: ${result.errorMessage}`);
+        }
+    }
+    /**
+     * Loads only the migration files that need to be applied, checking everything in one pass.
+     */
+    async loadUnappliedMigrations(migrationsDir, lastAppliedVersion) {
+        const migrations = [];
+        // Read directory and process files in one pass
+        const files = await readdir(migrationsDir);
+        for (const file of files) {
+            // Skip non-SQL files
+            if (!file.endsWith('.sql')) {
+                continue;
+            }
+            // Extract version from filename (e.g., V1__create_table.sql -> 1)
+            const version = this.extractVersionFromFilename(file);
+            if (version === null) {
+                throw new Error(`Invalid migration filename format: ${file}. Expected format: V{version}__{description}.sql`);
+            }
+            // Only load files that need to be applied
+            if (lastAppliedVersion === null || version > lastAppliedVersion) {
+                const filePath = join(migrationsDir, file);
+                const content = await readFile(filePath, 'utf8');
+                migrations.push({
+                    version,
+                    name: file,
+                    content
+                });
+            }
+        }
+        // Sort by version to ensure proper order
+        migrations.sort((a, b) => a.version - b.version);
+        return migrations;
+    }
+    /**
+     * Extracts the version number from a migration filename.
+     * Expected format: V{version}__{description}.sql
+     */
+    extractVersionFromFilename(filename) {
+        const match = filename.match(/^V(\d+)__.*\.sql$/);
+        return match ? parseInt(match[1], 10) : null;
+    }
+    logVerbose(message, verbose) {
+        if (verbose) {
+            this.logger.log(message);
+        }
+    }
+}

package/dist/internal/Utils.d.ts

@@ -0,0 +1,66 @@
+import { FunctionDefinition, ObjectC3Type } from '@kinotic-ai/idl';
+import { Project } from 'ts-morph';
+import { Logger } from './Logger.js';
+export type GeneratedServiceInfo = {
+    entityServiceName: string;
+    namedQueries: FunctionDefinition[];
+};
+export declare class SessionMetadata {
+    sessionId: string;
+    replyToId: string;
+    constructor(sessionId: string, replyToId: string);
+}
+export declare function jsonStringifyReplacer(key: any, value: any): any;
+/**
+ * Connects to the server and upgrades the session to a CLI session
+ * Currently this works by connecting and waiting for the clients session id on the event bus
+ * The cli then disconnects and reconnects using the clients' session.
+ * This will be replaced when the server supports a session upgrade command
+ * @param server the server to connect to
+ * @param logger the logger to use
+ * @param authHeadersFile path to a file containing the auth headers
+ * @return true if the session was upgraded successfully
+ */
+export declare function connectAndUpgradeSession(server: string, logger: Logger, authHeadersFile?: string): Promise<boolean>;
+export type EntityInfo = {
+    exportedFromFile: string;
+    defaultExport: boolean;
+    entity: ObjectC3Type;
+    multiTenantSelectionEnabled: boolean;
+};
+export type ConversionConfiguration = {
+    application: string;
+    entitiesPath: string;
+    verbose: boolean;
+    logger: Logger;
+};
+export declare function pathToTsGlobPath(path: string): string;
+export declare function createTsMorphProject(): Project;
+export declare function convertAllEntities(config: ConversionConfiguration): EntityInfo[];
+/**
+ * Will return the relative path from the 'from' path to the 'to' path
+ * @param from path to start from
+ * @param to path to end at
+ * @param fileExtensionForImports this is the file extension to append to the end of the relative path
+ */
+export declare function getRelativeImportPath(from: string, to: string, fileExtensionForImports?: string): string;
+/**
+ * Will return the name of the node module if the path is within a node module or null if not
+ * @param nodeModulePath to check
+ */
+export declare function tryGetNodeModuleName(nodeModulePath: string): string | null;
+/**
+ * Saves the C3Type to the local filesystem
+ * @param savePath to save the entities to
+ * @param entity to save
+ * @param logger to log to if desired, if null nothing will be logged
+ */
+export declare function writeEntityJsonToFilesystem(savePath: string, entity: ObjectC3Type, logger?: Logger): Promise<void>;
+/**
+ * Save the C3Type(s) to the local filesystem
+ * @param savePath to save the entities to
+ * @param entities to save
+ * @param logger to log to if desired, if null nothing will be logged
+ */
+export declare function writeEntitiesJsonToFilesystem(savePath: string, entities: ObjectC3Type[], logger?: Logger): Promise<void>;
+export declare function writeGeneratedServiceInfoToFilesystem(savePath: string, info: GeneratedServiceInfo, logger?: Logger): Promise<void>;

package/dist/internal/Utils.js

@@ -0,0 +1,349 @@
+import { Kinotic, Event, EventConstants, ParticipantConstants } from '@kinotic-ai/core';
+import { ObjectC3Type } from '@kinotic-ai/idl';
+import fs from 'fs';
+import fsPromises from 'fs/promises';
+import { confirm } from '@inquirer/prompts';
+import open from 'open';
+import pTimeout from 'p-timeout';
+import path from 'path';
+import { IndentationText, Node, Project } from 'ts-morph';
+import { v4 as uuidv4 } from 'uuid';
+import { createConversionContext } from './converter/IConversionContext.js';
+import { TypescriptConversionState } from './converter/typescript/TypescriptConversionState.js';
+import { TypescriptConverterStrategy } from './converter/typescript/TypescriptConverterStrategy.js';
+export class SessionMetadata {
+    sessionId;
+    replyToId;
+    constructor(sessionId, replyToId) {
+        this.sessionId = sessionId;
+        this.replyToId = replyToId;
+    }
+}
+function isEmpty(value) {
+    if (value === null || value === undefined) {
+        return true;
+    }
+    if (Array.isArray(value)) {
+        return value.every(isEmpty);
+    }
+    else if (typeof (value) === 'object') {
+        return Object.values(value).every(isEmpty);
+    }
+    return false;
+}
+export function jsonStringifyReplacer(key, value) {
+    return isEmpty(value)
+        ? undefined
+        : value;
+}
+/**
+ * Connects to the server and upgrades the session to a CLI session
+ * Currently this works by connecting and waiting for the clients session id on the event bus
+ * The cli then disconnects and reconnects using the clients' session.
+ * This will be replaced when the server supports a session upgrade command
+ * @param server the server to connect to
+ * @param logger the logger to use
+ * @param authHeadersFile path to a file containing the auth headers
+ * @return true if the session was upgraded successfully
+ */
+export async function connectAndUpgradeSession(server, logger, authHeadersFile) {
+    try {
+        const serverURL = new URL(server);
+        if (serverURL.protocol !== 'http:' && serverURL.protocol !== 'https:') {
+            logger.log('Invalid server URL, only http and https are supported');
+            return false;
+        }
+        let connectionInfo = { host: '' };
+        if (serverURL.hostname === 'localhost' || serverURL.hostname === '127.0.0.1') {
+            connectionInfo.host = serverURL.hostname;
+            connectionInfo.port = 58503;
+        }
+        else {
+            connectionInfo.host = serverURL.hostname;
+            if (serverURL.protocol === 'https:') {
+                connectionInfo.useSSL = true;
+                connectionInfo.port = 443;
+            }
+            if (serverURL.port) {
+                connectionInfo.port = Number(serverURL.port);
+            }
+            else if (!connectionInfo.useSSL) {
+                connectionInfo.port = 58503;
+            }
+        }
+        if (authHeadersFile) {
+            if (!fs.existsSync(authHeadersFile)) {
+                logger.log(`Authentication header file ${authHeadersFile} does not exist. Please provide a valid file.`);
+                return false;
+            }
+            else {
+                logger.log(`Authentication header file ${authHeadersFile} loaded successfully. Using authentication headers to connect to the Kinotic Server.`);
+            }
+            const authHeaders = JSON.parse(fs.readFileSync(authHeadersFile, 'utf8'));
+            connectionInfo.connectHeaders = authHeaders;
+            const connectedInfo = await pTimeout(Kinotic.connect(connectionInfo), {
+                milliseconds: 60000,
+                message: 'Connection timeout trying to connect to the Kinotic Server'
+            });
+            if (connectedInfo) {
+                return true;
+            }
+            else {
+                return false;
+            }
+        }
+        else {
+            connectionInfo.connectHeaders = {
+                login: ParticipantConstants.CLI_PARTICIPANT_ID
+            };
+            const connectedInfo = await pTimeout(Kinotic.connect(connectionInfo), {
+                milliseconds: 60000,
+                message: 'Connection timeout trying to connect to the Kinotic Server'
+            });
+            if (connectedInfo) {
+                // This works because any client can subscribe to a destination that is scoped to the connectedInfo.replyToId
+                const scope = connectedInfo.replyToId + ':' + uuidv4();
+                const url = server + (server.endsWith('/') ? '' : '/') + '#/sessionUpgrade/' + encodeURIComponent(scope);
+                logger.log('Authenticate your account at:');
+                logger.log(url);
+                const answer = await confirm({
+                    message: 'Open in browser?',
+                    default: true,
+                });
+                if (answer) {
+                    await open(url);
+                }
+                else {
+                    logger.log('Browser will not be opened. You must authenticate your account before continuing.');
+                }
+                const sessionMetadata = await receiveSessionId(scope);
+                await Kinotic.disconnect();
+                connectionInfo.connectHeaders = {
+                    session: sessionMetadata.sessionId
+                };
+                // Provide this so the continuum client will use the same replyToId as the session
+                connectionInfo.connectHeaders[EventConstants.REPLY_TO_ID_HEADER] = sessionMetadata.replyToId;
+                await Kinotic.connect(connectionInfo);
+                logger.log('Authenticated successfully\n');
+                return true;
+            }
+            else {
+                logger.log("Could not connect to the Kinotic Server. Please check the server is running and the URL is correct.");
+                return false;
+            }
+        }
+    }
+    catch (e) {
+        logger.log("Could not connect to the Kinotic Server. Please check the server is running and the URL is correct.", e);
+        return false;
+    }
+}
+function receiveSessionId(scope) {
+    const subscribeCRI = EventConstants.SERVICE_DESTINATION_PREFIX + scope + '@continuum.cli.SessionUpgradeService';
+    return new Promise((resolve, reject) => {
+        const subscription = Kinotic.eventBus.observe(subscribeCRI).subscribe((value) => {
+            // send reply to user
+            const replyTo = value.getHeader(EventConstants.REPLY_TO_HEADER);
+            if (replyTo) {
+                const replyEvent = new Event(replyTo);
+                const correlationId = value.getHeader(EventConstants.CORRELATION_ID_HEADER);
+                if (correlationId) {
+                    replyEvent.setHeader(EventConstants.CORRELATION_ID_HEADER, correlationId);
+                }
+                replyEvent.setHeader(EventConstants.CONTENT_TYPE_HEADER, EventConstants.CONTENT_JSON);
+                Kinotic.eventBus.send(replyEvent);
+            }
+            subscription.unsubscribe();
+            const jsonObj = JSON.parse(value.getDataString());
+            if (jsonObj?.length > 0) {
+                resolve(jsonObj[0]);
+            }
+            else {
+                reject('No Session Id found in data');
+            }
+        });
+    });
+}
+function getEntityDecoratorIfExists(node) {
+    if (Node.isClassDeclaration(node)) {
+        return node.getDecorator('Entity');
+    }
+}
+export function pathToTsGlobPath(path) {
+    return path.endsWith('.ts') ? path : (path.endsWith('/') ? path + '*.ts' : path + '/*.ts');
+}
+export function createTsMorphProject() {
+    const tsConfigFilePath = path.resolve('tsconfig.json');
+    if (!fs.existsSync(tsConfigFilePath)) {
+        throw new Error(`No tsconfig.json found in working directory: ${process.cwd()}`);
+    }
+    return new Project({
+        tsConfigFilePath: tsConfigFilePath,
+        manipulationSettings: {
+            indentationText: IndentationText.TwoSpaces
+        }
+        // compilerOptions: {
+        //     target: ScriptTarget.ES2020,
+        //     useDefineForClassFields: true,
+        //     module: ModuleKind.ES2020,
+        //     lib: ["ES2020"],
+        //     skipLibCheck: true,
+        //     downlevelIteration: true,
+        //     emitDecoratorMetadata: true,
+        //     experimentalDecorators: true,
+        //     esModuleInterop: true,
+        //     moduleResolution: ModuleResolutionKind.NodeNext,
+        //     resolveJsonModule: true,
+        //     isolatedModules: true,
+        //     noEmit: true,
+        // }
+    });
+}
+export function convertAllEntities(config) {
+    const entities = [];
+    const project = createTsMorphProject();
+    if (config.verbose) {
+        project.enableLogging(true);
+    }
+    let absEntitiesPath = path.resolve(config.entitiesPath);
+    if (!absEntitiesPath.endsWith('.ts') && !absEntitiesPath.endsWith(path.sep)) {
+        absEntitiesPath = absEntitiesPath + path.sep;
+    }
+    project.addSourceFilesAtPaths(pathToTsGlobPath(config.entitiesPath));
+    const sourceFiles = project.getSourceFiles();
+    for (const sourceFile of sourceFiles) {
+        const absSourcePath = path.resolve(sourceFile.getFilePath());
+        // make sure this file is in our configured paths and not just introduced by the ts-config
+        if (absSourcePath.startsWith(absEntitiesPath)) {
+            const conversionContext = createConversionContext(new TypescriptConverterStrategy(new TypescriptConversionState(config.application), config.logger));
+            const exportedDeclarations = sourceFile.getExportedDeclarations();
+            exportedDeclarations.forEach((exportedDeclarationEntries, name) => {
+                exportedDeclarationEntries.forEach((exportedDeclaration) => {
+                    if (Node.isClassDeclaration(exportedDeclaration) || Node.isInterfaceDeclaration(exportedDeclaration)) {
+                        const declaration = exportedDeclaration;
+                        // If the Entity is decorated with @Entity or has an EntityConfiguration we convert it
+                        const decorator = getEntityDecoratorIfExists(exportedDeclaration);
+                        if (decorator) {
+                            let c3Type = null;
+                            try {
+                                conversionContext.state().multiTenantSelectionEnabled = false;
+                                c3Type = conversionContext.convert(declaration.getType());
+                            }
+                            catch (e) {
+                            } // We ignore this error since the converter will print any errors
+                            if (c3Type != null) {
+                                if (c3Type instanceof ObjectC3Type) {
+                                    entities.push({
+                                        exportedFromFile: declaration.getSourceFile().getFilePath(),
+                                        defaultExport: declaration.isDefaultExport(),
+                                        entity: c3Type,
+                                        multiTenantSelectionEnabled: conversionContext.state().multiTenantSelectionEnabled
+                                    });
+                                }
+                                else {
+                                    throw new Error(`Could not convert ${name} to a C3Type`);
+                                }
+                            }
+                            else {
+                                throw new Error(`Could not convert ${name} to a C3Type`);
+                            }
+                        }
+                    }
+                });
+            });
+        }
+    }
+    return entities;
+}
+/**
+ * Will return the relative path from the 'from' path to the 'to' path
+ * @param from path to start from
+ * @param to path to end at
+ * @param fileExtensionForImports this is the file extension to append to the end of the relative path
+ */
+export function getRelativeImportPath(from, to, fileExtensionForImports = '') {
+    if (!from) {
+        throw new Error('from path is required');
+    }
+    if (!to) {
+        throw new Error('to path is required');
+    }
+    const fromDir = path.dirname(from);
+    let relativePath = path.relative(fromDir, to);
+    // Normalize path separators to forward slashes for import statements
+    // This is required because import statements always use forward slashes,
+    // even on Windows, but path.relative() returns platform-specific separators
+    relativePath = relativePath.replace(/\\/g, '/');
+    // Make sure path starts with './' or '../'
+    if (!relativePath.startsWith('../') && !relativePath.startsWith('./')) {
+        relativePath = `./${relativePath}`;
+    }
+    // Remove '.ts' extension
+    relativePath = relativePath.replace(/\.ts$/, '');
+    return relativePath + fileExtensionForImports;
+}
+/**
+ * Will return the name of the node module if the path is within a node module or null if not
+ * @param nodeModulePath to check
+ */
+export function tryGetNodeModuleName(nodeModulePath) {
+    let ret = null;
+    if (nodeModulePath.includes('node_modules')) {
+        const nodeModuleIdx = nodeModulePath.indexOf('node_modules/');
+        const partBeforeNodeModules = nodeModulePath.slice(0, nodeModuleIdx + 13);
+        const partAfterNodeModules = nodeModulePath.slice(nodeModuleIdx + 13);
+        const parts = partAfterNodeModules.split('/');
+        let previousPartPath = '';
+        for (let part of parts) {
+            const packagePath = path.resolve(partBeforeNodeModules, previousPartPath, part, 'package.json');
+            if (fs.existsSync(packagePath)) {
+                const packageJson = JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+                ret = packageJson.name;
+                break;
+            }
+            else {
+                previousPartPath = part + '/';
+            }
+        }
+    }
+    return ret;
+}
+/**
+ * Saves the C3Type to the local filesystem
+ * @param savePath to save the entities to
+ * @param entity to save
+ * @param logger to log to if desired, if null nothing will be logged
+ */
+export async function writeEntityJsonToFilesystem(savePath, entity, logger) {
+    const json = JSON.stringify(entity, jsonStringifyReplacer, 2);
+    if (json && json.length > 0) {
+        const outputPath = path.resolve(savePath, 'generated', 'entity-definitions', `${entity.namespace}.${entity.name}.json`);
+        await fsPromises.mkdir(path.dirname(outputPath), { recursive: true });
+        await fsPromises.writeFile(outputPath, json);
+        if (logger) {
+            logger.log(`Wrote ${entity.namespace}.${entity.name} to ${outputPath}`);
+        }
+    }
+}
+/**
+ * Save the C3Type(s) to the local filesystem
+ * @param savePath to save the entities to
+ * @param entities to save
+ * @param logger to log to if desired, if null nothing will be logged
+ */
+export async function writeEntitiesJsonToFilesystem(savePath, entities, logger) {
+    for (const entity of entities) {
+        await writeEntityJsonToFilesystem(savePath, entity, logger);
+    }
+}
+export async function writeGeneratedServiceInfoToFilesystem(savePath, info, logger) {
+    const json = JSON.stringify(info, jsonStringifyReplacer, 2);
+    if (json && json.length > 0) {
+        const outputPath = path.resolve(savePath, 'generated', 'query-definitions', `${info.entityServiceName}.json`);
+        await fsPromises.mkdir(path.dirname(outputPath), { recursive: true });
+        await fsPromises.writeFile(outputPath, json);
+        if (logger) {
+            logger.log(`Wrote ${info.entityServiceName} named queries to ${outputPath}`);
+        }
+    }
+}

package/dist/internal/converter/ConverterConstants.d.ts

@@ -0,0 +1,3 @@
+export declare enum ConverterConstants {
+    SOURCE_FILE_PATH = "sourceFilePath"
+}

package/dist/internal/converter/ConverterConstants.js

@@ -0,0 +1,4 @@
+export var ConverterConstants;
+(function (ConverterConstants) {
+    ConverterConstants["SOURCE_FILE_PATH"] = "sourceFilePath";
+})(ConverterConstants || (ConverterConstants = {}));

package/dist/internal/converter/DefaultConversionContext.d.ts

@@ -0,0 +1,29 @@
+import { IConversionContext } from './IConversionContext.js';
+import { IConverterStrategy } from './IConverterStrategy.js';
+/**
+ * Created by Navíd Mitchell 🤪 on 4/26/23.
+ */
+export declare class DefaultConversionContext<T, R, S> implements IConversionContext<T, R, S> {
+    private readonly strategy;
+    private readonly conversionDepthStack;
+    private readonly errorStack;
+    private readonly _state;
+    private readonly logger;
+    private _actualJsonPath;
+    private _actualPropertyStack;
+    propertyStack: string[];
+    currentJsonPath: string;
+    constructor(strategy: IConverterStrategy<T, R, S>);
+    beginProcessingProperty(name: string): void;
+    endProcessingProperty(): void;
+    get actualJsonPath(): string;
+    get actualPropertyStack(): string[];
+    convert(value: T): R;
+    state(): S;
+    private selectConverter;
+    /**
+     * Log an exception when appropriate dealing with only logging once even when recursion has occurred
+     * @param e to log
+     */
+    private logException;
+}

package/dist/internal/converter/DefaultConversionContext.js

@@ -0,0 +1,112 @@
+/**
+ * Created by Navíd Mitchell 🤪 on 4/26/23.
+ */
+export class DefaultConversionContext {
+    strategy;
+    conversionDepthStack = [];
+    errorStack = [];
+    _state;
+    logger;
+    _actualJsonPath = '';
+    _actualPropertyStack = [];
+    propertyStack = [];
+    currentJsonPath = '';
+    constructor(strategy) {
+        this.strategy = strategy;
+        let state = strategy.initialState();
+        if (state instanceof Function) {
+            this._state = state();
+        }
+        else {
+            this._state = state;
+        }
+        let logger = strategy.logger();
+        if (logger instanceof Function) {
+            this.logger = logger();
+        }
+        else {
+            this.logger = logger;
+        }
+    }
+    beginProcessingProperty(name) {
+        this.currentJsonPath = (this.propertyStack.length > 0 ? this.propertyStack[this.propertyStack.length - 1] + '.' : '') + name;
+        this.propertyStack.push(this.currentJsonPath);
+        this._actualJsonPath = (this._actualPropertyStack.length > 0 ? this._actualPropertyStack[this._actualPropertyStack.length - 1] + '.' : '') + name;
+        this._actualPropertyStack.push(this._actualJsonPath);
+    }
+    endProcessingProperty() {
+        this.propertyStack.pop();
+        this.currentJsonPath = this.propertyStack.length > 0 ? this.propertyStack[this.propertyStack.length - 1] : '';
+        this._actualPropertyStack.pop();
+        this._actualJsonPath = this._actualPropertyStack.length > 0 ? this._actualPropertyStack[this._actualPropertyStack.length - 1] : '';
+    }
+    get actualJsonPath() {
+        return this._actualJsonPath;
+    }
+    get actualPropertyStack() {
+        return this._actualPropertyStack;
+    }
+    convert(value) {
+        try {
+            this.conversionDepthStack.unshift(value);
+            let converter = this.selectConverter(value);
+            if (converter != null) {
+                return converter.convert(value, this);
+            }
+            else {
+                // this causes the stack to unwind, so this is intentional
+                // noinspection ExceptionCaughtLocallyJS
+                throw new Error('No ITypeConverter can be found for ' + this.strategy.valueToString(value) + '\nWhen using strategy ' + this.strategy.constructor.name);
+            }
+        }
+        catch (e) {
+            this.logException(e);
+            throw e;
+        }
+        finally {
+            this.conversionDepthStack.shift();
+        }
+    }
+    state() {
+        return this._state;
+    }
+    selectConverter(value) {
+        let ret = null;
+        for (let converter of this.strategy.typeConverters()) {
+            if (converter.supports(value, this.state())) {
+                ret = converter;
+                break;
+            }
+        }
+        return ret;
+    }
+    /**
+     * Log an exception when appropriate dealing with only logging once even when recursion has occurred
+     * @param e to log
+     */
+    logException(e) {
+        // This indicates this is the first time logException has been called for this context.
+        // This would occur at the furthest call depth so at this point the conversionDepthStack has the complete stack
+        if (this.errorStack.length === 0) {
+            // We loop vs add all to keep stack intact
+            for (let value of this.conversionDepthStack) {
+                this.errorStack.unshift(value);
+            }
+        }
+        if (this.conversionDepthStack.length === 1) { // we are at the top of the stack during recursion
+            let sb = `\nError occurred during conversion.\nException: ${e.message}\nJsonPath: ${this.currentJsonPath}\nConversion Stack:\n`;
+            let objectCount = 1;
+            for (let value of this.errorStack) {
+                const spacer = '  '.repeat(objectCount);
+                sb += spacer;
+                sb += '- ';
+                sb += this.strategy.valueToString(value)
+                    .replaceAll('\n', '\n  ' + spacer);
+                sb += '\n';
+                objectCount++;
+            }
+            this.logger.log(sb);
+            this.errorStack.length = 0; // we have printed reset
+        }
+    }
+}