@datapos/datapos-shared 0.3.404 → 0.3.406

package/dist/datapos-shared-connector.es.js

@@ -1,13 +1,13 @@
-import { l as s, o as l, n as c, a as b, r as u, b as m, m as p, s as t, d as r, e as d, f as C, g as h, D as g } from "./index-5UsJyepS.js";
-const f = s(["apiKey", "disabled", "oAuth2", "none"]), v = l({
-  authMethodId: f,
-  activeConnectionCount: r(d()),
-  canDescribe: r(h()),
-  id: r(t()),
-  label: r(C),
-  maxConnectionCount: r(d()),
-  params: r(b(u(t(), t())))
-}), S = s(["application", "curatedDataset", "database", "fileStore"]), L = s([
+import { l as n, o as i, n as a, a as d, r as b, b as g, m as u, s as e, d as o, e as s, f as p, g as C, D as l } from "./index-5UsJyepS.js";
+const h = n(["apiKey", "disabled", "oAuth2", "none"]), S = i({
+  authMethodId: h,
+  activeConnectionCount: o(s()),
+  canDescribe: o(C()),
+  id: o(e()),
+  label: o(p),
+  maxConnectionCount: o(s()),
+  params: o(d(b(e(), e())))
+}), f = n(["application", "curatedDataset", "database", "fileStore"]), y = n([
   "abortOperation",
   "authenticateConnection",
   "createObject",
@@ -22,39 +22,34 @@ const f = s(["apiKey", "disabled", "oAuth2", "none"]), v = l({
   "retrieveChunks",
   "retrieveRecords",
   "upsertRecords"
-]), y = s(["bidirectional", "destination", "source", "unknown"]), j = l({
-  ...p,
-  typeId: m("connector"),
-  category: c(l({ id: t(), label: t() })),
-  categoryId: S,
-  implementations: u(t(), v),
-  operations: b(L),
-  usageId: y,
-  vendorAccountURL: c(t()),
-  vendorDocumentationURL: c(t()),
-  vendorHomeURL: c(t())
-}), i = (o) => {
-  const n = Object.entries(o).filter((e) => typeof e[1] == "string");
-  return new Map(n);
-}, D = [
-  { id: "application", labels: i({ "en-gb": "Application" }) },
-  { id: "curatedDataset", labels: i({ "en-gb": "Curated Dataset" }) },
-  { id: "database", labels: i({ "en-gb": "Database" }) },
-  { id: "fileStore", labels: i({ "en-gb": "File Store" }) }
-], O = (o, n, e = g) => {
-  const a = o.get(n);
-  if (a !== void 0) return a;
-  if (e !== n)
-    return o.get(e);
-}, A = (o, n = g) => {
-  const e = D.find((a) => a.id === o);
-  if (e) {
-    const a = O(e.labels, n);
-    return { id: e.id, label: a ?? e.id };
+]), D = n(["bidirectional", "destination", "source", "unknown"]), v = i({
+  id: e(),
+  label: e()
+}), R = i({
+  ...u,
+  typeId: g("connector"),
+  category: a(v),
+  categoryId: f,
+  implementations: b(e(), S),
+  operations: d(y),
+  usageId: D,
+  vendorAccountURL: a(e()),
+  vendorDocumentationURL: a(e()),
+  vendorHomeURL: a(e())
+}), I = [
+  { id: "application", labels: { "en-gb": "Application" } },
+  { id: "curatedDataset", labels: { "en-gb": "Curated Dataset" } },
+  { id: "database", labels: { "en-gb": "Database" } },
+  { id: "fileStore", labels: { "en-gb": "File Store" } }
+], A = (c, m = l) => {
+  const t = I.find((r) => r.id === c);
+  if (t) {
+    const r = t.labels[m] ?? t.labels[l] ?? t.id;
+    return { id: t.id, label: r };
   }
-  return { id: o, label: o };
+  return { id: c, label: c };
 };
 export {
-  j as connectorConfigSchema,
+  R as connectorConfigSchema,
   A as getConnectorCategory
 };

package/dist/types/src/component/connector/connectorConfig.schema.d.ts

@@ -29,6 +29,10 @@ export declare const connectorCategoryIdSchema: import('valibot').UnionSchema<re
 export declare const connectorOperationNameSchema: import('valibot').UnionSchema<readonly [import('valibot').LiteralSchema<"abortOperation", undefined>, import('valibot').LiteralSchema<"authenticateConnection", undefined>, import('valibot').LiteralSchema<"createObject", undefined>, import('valibot').LiteralSchema<"describeConnection", undefined>, import('valibot').LiteralSchema<"dropObject", undefined>, import('valibot').LiteralSchema<"findObjectFolderPath", undefined>, import('valibot').LiteralSchema<"getReadableStream", undefined>, import('valibot').LiteralSchema<"getRecord", undefined>, import('valibot').LiteralSchema<"listNodes", undefined>, import('valibot').LiteralSchema<"previewObject", undefined>, import('valibot').LiteralSchema<"removeRecords", undefined>, import('valibot').LiteralSchema<"retrieveChunks", undefined>, import('valibot').LiteralSchema<"retrieveRecords", undefined>, import('valibot').LiteralSchema<"upsertRecords", undefined>], undefined>;
 /** Connector data pipeline usage identifiers. */
 export declare const connectorUsageIdSchema: import('valibot').UnionSchema<readonly [import('valibot').LiteralSchema<"bidirectional", undefined>, import('valibot').LiteralSchema<"destination", undefined>, import('valibot').LiteralSchema<"source", undefined>, import('valibot').LiteralSchema<"unknown", undefined>], undefined>;
+export declare const connectorCategorySchema: import('valibot').ObjectSchema<{
+    readonly id: import('valibot').StringSchema<undefined>;
+    readonly label: import('valibot').StringSchema<undefined>;
+}, undefined>;
 /** Top-level connector configuration object. */
 export declare const connectorConfigSchema: import('valibot').ObjectSchema<{
     readonly typeId: import('valibot').LiteralSchema<"connector", undefined>;

package/dist/types/src/component/connector/index.d.ts

@@ -3,7 +3,7 @@ import { Component } from '..';
 import { ToolConfig } from '../tool';
 import { ValueDelimiterId } from '../dataView';
 import { ConnectionConfig, ConnectionDescription, ConnectionNodeConfig } from './connection';
-import { connectorConfigSchema, connectorOperationNameSchema, connectorUsageIdSchema } from './connectorConfig.schema';
+import { connectorCategorySchema, connectorConfigSchema, connectorOperationNameSchema, connectorUsageIdSchema } from './connectorConfig.schema';
 /** Authentication method identifiers supported by a connector implementation. */
 /** Connector implementation. */
 /** Category identifiers used for grouping and filtering connectors. */
@@ -25,86 +25,68 @@ interface ConnectorInterface extends Component {
     readonly toolConfigs: ToolConfig[];
     abortOperation?(connector: ConnectorInterface): void;
     authenticateConnection?(accountId: string, windowCenterX: number, windowCenterY: number): Window;
-    createObject?(connector: ConnectorInterface, settings: CreateSettings): Promise<void>;
-    describeConnection?(connector: ConnectorInterface, settings: DescribeSettings): Promise<DescribeResult>;
-    dropObject?(connector: ConnectorInterface, settings: DropSettings): Promise<void>;
-    findObject?(connector: ConnectorInterface, settings: FindObjectFolderPathSettings): Promise<string | null>;
-    getReadableStream?(connector: ConnectorInterface, settings: GetReadableStreamSettings): Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;
-    getRecord?(connector: ConnectorInterface, settings: GetRecordSettings): Promise<GetRecordResult>;
-    listNodes?(connector: ConnectorInterface, settings: ListSettings): Promise<ListResult>;
-    previewObject?(connector: ConnectorInterface, settings: PreviewSettings): Promise<PreviewResult>;
-    removeRecords?(connector: ConnectorInterface, settings: RemoveSettings): Promise<void>;
-    retrieveChunks?(connector: ConnectorInterface, settings: RetrieveChunksSettings, chunk: (records: (string[] | Record<string, unknown>)[]) => void, complete: (result: RetrieveChunksSummary) => void): Promise<void>;
-    retrieveRecords?(connector: ConnectorInterface, settings: RetrieveRecordsSettings, chunk: (records: (string[] | Record<string, unknown>)[]) => void, complete: (result: RetrieveRecordsSummary) => void): Promise<void>;
-    upsertRecords?(connector: ConnectorInterface, settings: UpsertSettings): Promise<void>;
-}
-/** Connector operation settings. */
-interface ConnectorOperationSettings {
+    createObject?(connector: ConnectorInterface, options: CreateOptions): Promise<void>;
+    describeConnection?(connector: ConnectorInterface, options: DescribeOptions): Promise<DescribeResult>;
+    dropObject?(connector: ConnectorInterface, options: DropOptions): Promise<void>;
+    findObject?(connector: ConnectorInterface, options: FindObjectFolderPathOptions): Promise<string | null>;
+    getReadableStream?(connector: ConnectorInterface, options: GetReadableStreamOptions): Promise<ReadableStream<Uint8Array<ArrayBuffer>>>;
+    getRecord?(connector: ConnectorInterface, options: GetRecordOptions): Promise<GetRecordResult>;
+    listNodes?(connector: ConnectorInterface, options: ListNodesOptions): Promise<ListNodesResult>;
+    previewObject?(connector: ConnectorInterface, options: PreviewObjectOptions): Promise<PreviewObjectResult>;
+    removeRecords?(connector: ConnectorInterface, options: RemoveOptions): Promise<void>;
+    retrieveChunks?(connector: ConnectorInterface, options: RetrieveChunksOptions): Promise<void>;
+    retrieveRecords?(connector: ConnectorInterface, options: RetrieveRecordsOptions): Promise<void>;
+    upsertRecords?(connector: ConnectorInterface, options: UpsertOptions): Promise<void>;
+}
+/** Connector operation options. */
+interface ConnectorOperationOptions {
     accountId?: string;
     appCheckToken?: string;
     sessionAccessToken?: string;
 }
-/** Get find object folder path settings. */
-interface FindObjectFolderPathSettings extends ConnectorOperationSettings {
+/** Find object folder path options. */
+interface FindObjectFolderPathOptions extends ConnectorOperationOptions {
     containerName: string | undefined;
     nodeId: string;
 }
-/** Get readable stream settings. */
-interface GetReadableStreamSettings extends ConnectorOperationSettings {
+/** Get readable stream options. */
+interface GetReadableStreamOptions extends ConnectorOperationOptions {
     id: string;
     path: string;
 }
-interface CreateSettings extends ConnectorOperationSettings {
-    accountId?: string;
-    path: string;
-    structure: string;
-}
-type DescribeSettings = ConnectorOperationSettings;
-interface DescribeResult {
-    description: ConnectionDescription;
-}
-interface DropSettings extends ConnectorOperationSettings {
-    path: string;
-}
-interface GetRecordSettings extends ConnectorOperationSettings {
-    id: string;
-    path: string;
-}
-interface GetRecordResult {
-    record?: string[] | Record<string, unknown>;
-}
-interface ListSettings extends ConnectorOperationSettings {
+/** List nodes options and result. */
+interface ListNodesOptions extends ConnectorOperationOptions {
     folderPath: string;
     limit?: number;
     offset?: number;
     totalCount?: number;
 }
-interface ListResult {
+interface ListNodesResult {
     cursor: string | number | undefined;
     connectionNodeConfigs: ConnectionNodeConfig[];
     isMore: boolean;
     totalCount: number;
 }
-interface PreviewSettings extends ConnectorOperationSettings {
+/** Preview object options and result. */
+interface PreviewObjectOptions extends ConnectorOperationOptions {
     chunkSize?: number;
     extension?: string;
     path: string;
 }
-interface PreviewResult {
+interface PreviewObjectResult {
     data: Record<string, unknown>[] | Uint8Array;
     typeId: 'jsonArray' | 'uint8Array';
 }
-interface RemoveSettings extends ConnectorOperationSettings {
-    keys: string[];
-    path: string;
-}
-interface RetrieveChunksSettings extends ConnectorOperationSettings {
+/** Retrieve records options and summary. */
+interface RetrieveRecordsOptions extends ConnectorOperationOptions {
     chunkSize?: number;
     encodingId: string;
     path: string;
     valueDelimiterId: ValueDelimiterId;
+    chunk: (records: (string[] | Record<string, unknown>)[]) => void;
+    complete: (result: RetrieveRecordsSummary) => void;
 }
-interface RetrieveChunksSummary {
+interface RetrieveRecordsSummary {
     byteCount: number;
     commentLineCount: number;
     emptyLineCount: number;
@@ -112,13 +94,38 @@ interface RetrieveChunksSummary {
     lineCount: number;
     recordCount: number;
 }
-interface RetrieveRecordsSettings extends ConnectorOperationSettings {
+interface CreateOptions extends ConnectorOperationOptions {
+    accountId?: string;
+    path: string;
+    structure: string;
+}
+type DescribeOptions = ConnectorOperationOptions;
+interface DescribeResult {
+    description: ConnectionDescription;
+}
+interface DropOptions extends ConnectorOperationOptions {
+    path: string;
+}
+interface GetRecordOptions extends ConnectorOperationOptions {
+    id: string;
+    path: string;
+}
+interface GetRecordResult {
+    record?: string[] | Record<string, unknown>;
+}
+interface RemoveOptions extends ConnectorOperationOptions {
+    keys: string[];
+    path: string;
+}
+interface RetrieveChunksOptions extends ConnectorOperationOptions {
     chunkSize?: number;
     encodingId: string;
     path: string;
     valueDelimiterId: ValueDelimiterId;
+    chunk: (records: (string[] | Record<string, unknown>)[]) => void;
+    complete: (result: RetrieveChunksSummary) => void;
 }
-interface RetrieveRecordsSummary {
+interface RetrieveChunksSummary {
     byteCount: number;
     commentLineCount: number;
     emptyLineCount: number;
@@ -126,18 +133,15 @@ interface RetrieveRecordsSummary {
     lineCount: number;
     recordCount: number;
 }
-interface UpsertSettings extends ConnectorOperationSettings {
+interface UpsertOptions extends ConnectorOperationOptions {
     records: Record<string, unknown>[];
     path: string;
 }
 /** Types/Interfaces/Operations - Connector category. */
-interface ConnectorCategory {
-    id: string;
-    label: string;
-}
+type ConnectorCategory = InferOutput<typeof connectorCategorySchema>;
 declare const getConnectorCategory: (id: string, localeId?: import('../../index').LocaleCode) => ConnectorCategory;
 /** Exports. */
 export { getConnectorCategory };
 export type { ConnectionColumnConfig, ConnectionConfig, ConnectionNodeConfig, Encoding, UsageTypeId } from './connection';
-export type { ConnectorConfig, ConnectorInterface, ConnectorLocalisedConfig, ConnectorOperationName, ConnectorOperationSettings, ConnectorUsageId, CreateSettings, DropSettings, FindObjectFolderPathSettings, GetReadableStreamSettings, GetRecordResult, GetRecordSettings, ListResult, ListSettings, PreviewResult, PreviewSettings, RemoveSettings, RetrieveChunksSettings, RetrieveChunksSummary, RetrieveRecordsSettings, RetrieveRecordsSummary, UpsertSettings };
+export type { ConnectorConfig, ConnectorInterface, ConnectorLocalisedConfig, ConnectorOperationName, ConnectorOperationOptions, ConnectorUsageId, CreateOptions, DropOptions, FindObjectFolderPathOptions, GetReadableStreamOptions, GetRecordResult, GetRecordOptions, ListNodesResult, ListNodesOptions, PreviewObjectResult, PreviewObjectOptions, RemoveOptions, RetrieveChunksOptions, RetrieveChunksSummary, RetrieveRecordsOptions, RetrieveRecordsSummary, UpsertOptions };
 export { connectorConfigSchema } from './connectorConfig.schema';

package/dist/types/src/engine/index.d.ts

@@ -1,5 +1,5 @@
 import { ConnectionConfig } from '../component/connector/connection';
-import { ConnectorOperationSettings } from '../component/connector';
+import { ConnectorOperationOptions } from '../component/connector';
 import { ModuleConfig } from '../component/module';
 import { ToolConfig } from '../component/tool';
 import { ContextCallbackData, ContextConfig, ContextOperationSettings } from '../component/context';
@@ -14,8 +14,8 @@ interface EngineInitialiseSettings {
     toolConfigs: ToolConfig[];
 }
 type InitialiseEngine = (settings: EngineInitialiseSettings) => Promise<void>;
-type ProcessConnectorRequest = (id: string, connectionConfig: ConnectionConfig, settings: ConnectorOperationSettings, callback?: (callbackData: ContextCallbackData) => void) => Promise<unknown>;
-interface AuditContentSettings extends ConnectorOperationSettings {
+type ProcessConnectorRequest = (id: string, connectionConfig: ConnectionConfig, settings: ConnectorOperationOptions, callback?: (callbackData: ContextCallbackData) => void) => Promise<unknown>;
+interface AuditContentSettings extends ConnectorOperationOptions {
     chunkSize?: number;
     encodingId: string;
     path: string;

package/dist/types/src/index.d.ts

@@ -29,10 +29,6 @@ export type { DataFormatId, EncodingConfig, RecordDelimiterId, ValueDelimiterId
 export type { DataViewConfig, DataViewContentAuditConfig, DataViewLocalisedConfig, DataViewPreviewConfig, DataViewRelationshipsAuditConfig, ParsedValue } from './component/dataView';
 /** Interfaces/Types - Dimension. */
 export type { DimensionConfig, DimensionLocalisedConfig } from './component/dimension';
-/** Interfaces/Types */
-export type { SerialisedError } from './errors';
-/** Errors */
-/** Utilities */
 /** Interfaces/Types - Event query. */
 export type { EventQueryConfig, EventQueryLocalisedConfig } from './component/eventQuery';
 /** Interfaces/Types */

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@datapos/datapos-shared",
-    "version": "0.3.404",
+    "version": "0.3.406",
     "description": "A library containing common constants, types and utilities used across all Data Positioning projects.",
     "license": "MIT",
     "author": "Jonathan Terrell <terrell.jm@gmail.com>",