@cloudquery/plugin-sdk-javascript/dist/memdb/memdb.js

This is the high-level package to use for developing CloudQuery plugins in JavaScript

import { default as Ajv } from 'ajv';
import { ValidationError } from '../errors/errors.js';
import { newPlugin } from '../plugin/plugin.js';
import { sync } from '../scheduler/scheduler.js';
import { filterTables } from '../schema/table.js';
import { createDeleteStale } from './delete-stale.js';
import { createOverwrite } from './overwrite.js';
import { createRead } from './read.js';
import { createTables } from './tables.js';
import { createWrite } from './write.js';
export const createMemDBClient = () => {
    //eslint-disable-next-line @typescript-eslint/no-explicit-any
    const memoryDB = {};
    const tables = {};
    return {
        id: () => 'memdb',
        memoryDB,
        tables,
    };
};
const spec = {
    type: 'object',
    properties: {
        concurrency: { type: 'integer' },
    },
};
const ajv = new Ajv.default();
const validate = ajv.compile(spec);
export const newMemDBPlugin = () => {
    const memdbClient = createMemDBClient();
    const memoryDB = memdbClient.memoryDB;
    const tables = memdbClient.tables;
    const overwrite = createOverwrite(memoryDB);
    const deleteStale = createDeleteStale(memoryDB);
    const write = createWrite(memoryDB, tables, overwrite, deleteStale);
    const read = createRead(memoryDB);
    const allTables = createTables();
    const pluginClient = {
        plugin: null,
        spec: null,
        close: () => Promise.resolve(),
        tables: (options) => {
            const { tables, skipTables, skipDependentTables } = options;
            const filtered = filterTables(allTables, tables, skipTables, skipDependentTables);
            return Promise.resolve(filtered);
        },
        sync: async (options) => {
            const { stream, tables, skipTables, skipDependentTables, deterministicCQId } = options;
            const filtered = filterTables(allTables, tables, skipTables, skipDependentTables);
            const logger = pluginClient.plugin.getLogger();
            const { spec: { concurrency }, } = pluginClient;
            return await sync({
                logger,
                client: memdbClient,
                stream,
                tables: filtered,
                deterministicCQId,
                concurrency,
            });
        },
        write,
        read,
    };
    const newClient = (logger, spec, { noConnection }) => {
        if (noConnection) {
            return Promise.resolve(pluginClient);
        }
        const parsedSpec = JSON.parse(spec);
        const validSchema = validate(parsedSpec);
        if (!validSchema) {
            const messages = validate.errors?.map((error) => error.message).join(', ');
            return Promise.reject(new ValidationError(`Invalid spec: ${messages}`, { props: { spec } }));
        }
        const { concurrency = 10_000 } = parsedSpec;
        pluginClient.spec = { concurrency };
        return Promise.resolve(pluginClient);
    };
    const plugin = newPlugin('memdb', '0.0.1', newClient, {
        team: 'cloudquery',
        kind: 'source',
        jsonSchema: `{
  "$schema": "https://json-schema.org/draft/2020-12/schema",
  "$id": "https://github.com/cloudquery/plugin-sdk-javascript/memdb/spec",
  "$ref": "#/$defs/Spec",
  "$defs": {
    "Spec": {
      "properties": {
        "concurrency": {
          "type": "integer",
          "minimum": 1,
          "description": "Concurrency."
        }
      },
      "additionalProperties": false,
      "type": "object",
    },
  }
}`,
    });
    pluginClient.plugin = plugin;
    return plugin;
};
//# sourceMappingURL=memdb.js.map