@thescaffold/jsx-polylog 0.0.0

package/README.md

@@ -0,0 +1,159 @@
+# Scaffold
+
+## JSX Polylog
+
+### Introduction
+
+This is the javascript SDK for scaffold platform. It covers APIs for the following services:
+
+- Events
+- Files
+- Forms
+- Jobs
+- Logs
+- Messages
+- Motion
+- Webhooks
+
+### Supported Platforms
+
+- Browser
+- Node.js (Javascript/Typescript)
+
+### Installation
+
+1. NPM
+
+```bash
+$ npm i @thescaffold/jsx-polylog
+```
+
+2. CDN
+
+```html
+
+```
+
+### Usage & API
+
+1. Initialization
+
+```ts
+import { init } from '@thescaffold/jsx-polylog';
+
+init({
+  // config
+});
+```
+
+2. Events
+
+- identify
+
+```ts
+import { events } from '@thescaffold/jsx-polylog';
+
+events.identify(id, payload, options);
+```
+
+- track
+
+```ts
+import { events } from '@thescaffold/jsx-polylog';
+
+events.track(id, payload, options);
+```
+
+3. Jobs
+
+- Schedule a new job
+
+```
+  import { jobs } from '@thescaffold/jsx-polylog'
+
+  jobs.schedule(id, payload, options)
+```
+
+4. Files
+
+- Upload file
+
+```
+  import { files } from '@thescaffold/jsx-polylog'
+
+  files.upload(name, files, options)
+```
+
+5. Forms
+
+- Submit form
+
+```
+  import { forms } from '@thescaffold/jsx-polylog'
+
+  forms.submit(name, payload, options)
+```
+
+6. Webhooks
+
+- register webhook
+
+```
+  import { webhooks } from '@thescaffold/jsx-polylog'
+
+
+  webhooks.register(name, payload, options)
+```
+
+7. Logs
+
+- identify
+
+```ts
+import { events } from '@thescaffold/jsx-polylog';
+
+events.identify(id, payload, options);
+```
+
+- track
+
+```ts
+import { events } from '@thescaffold/jsx-polylog';
+
+events.track(id, payload, options);
+```
+
+## Commands
+
+DTS scaffolds your new library inside `/src`.
+
+To run DTS, use:
+
+```bash
+npm start # or yarn start
+```
+
+This builds to `/dist` and runs the project in watch mode so any edits you save inside `src` causes a rebuild to `/dist`.
+
+To do a one-off build, use `npm run build` or `yarn build`.
+
+To run tests, use `npm test` or `yarn test`.
+
+## Custom Commands
+
+```
+# build and sync locally
+$ node ./build --env=dev --sync=true
+
+# build and publish
+$ node ./build --env=prod --sync=true --version=x.x.x
+```
+
+## Publish
+
+```
+$ git tag <version e.g v0.0.0>
+$ git push origin <version>
+```
+
+## License

package/common/init/config.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../utils/values';
+export declare const getConfig: () => Config;

package/common/init/index.d.ts

@@ -0,0 +1,2 @@
+import { Config } from '../utils/values';
+export declare const init: (c: Config | any) => void;

package/common/queue/index.d.ts

@@ -0,0 +1,4 @@
+import { Item } from '../utils/values';
+export declare const push: (...items: Item[]) => void;
+export declare const pop: (length?: number) => Item[];
+export declare const length: () => number;

package/common/utils/functions.d.ts

@@ -0,0 +1,8 @@
+import { Config, LogType } from './values';
+export declare const isNode: () => boolean;
+export declare const isBrowser: () => boolean;
+export declare const isObject: (x: any) => boolean;
+export declare const recursiveMerge: (target: any, ...sources: any[]) => any;
+export declare const managedLog: (title: string, message: any, config: Config, ...types: LogType[]) => void;
+export declare const sleep: (ms: number) => Promise<unknown>;
+export declare function isFunction(value: any): boolean;

package/common/utils/values.d.ts

@@ -0,0 +1,197 @@
+export type Data = Record<string, any>;
+export declare enum EventEntityType {
+    Source = "source",
+    Channel = "channel"
+}
+export declare enum CategoryType {
+    Form = "form",
+    File = "file",
+    Webhook = "webhook",
+    Job = "job",
+    Event = "event",
+    Log = "log",
+    Motion = "motion",
+    Message = "message",
+    Others = "others"
+}
+export interface Item {
+    category: CategoryType;
+    payload: any;
+    entityId?: string;
+    entityName?: EventEntityType;
+    reference?: string;
+    version?: string;
+    sourceId?: string;
+    source?: string;
+    type?: string;
+}
+export interface Items {
+    items: Item[];
+}
+export declare enum LogType {
+    INFO = "info",
+    WARN = "warn",
+    ERROR = "error"
+}
+export interface EventData extends Data {
+}
+export interface FileData extends Data {
+    name: string;
+    file: string;
+    mime?: string;
+    size?: string;
+}
+export interface FormData extends Data {
+}
+export interface JobData extends Data {
+    url: string;
+    frequency: string;
+    startAt: string;
+    endAt: string;
+}
+export interface LogData extends Data {
+    time?: string;
+    type: LogType;
+    message: string;
+    data?: Data;
+    title?: string;
+}
+export interface WebhookRegisterData extends Data {
+    events: string[];
+    url: string;
+}
+export interface WebhookDispatchData extends Data {
+    event: string;
+    data?: Data;
+}
+export interface MessageData extends Data {
+    type: 'identify' | 'track';
+    channel: 'email' | 'sms' | 'push' | 'webhook' | string;
+    template: string;
+    data?: Data;
+    provider?: string;
+    from?: string;
+    to?: string;
+    replyTo?: string;
+    subject?: string;
+}
+export interface MotionData extends Data {
+    type: 'identify' | 'track';
+    data?: Data;
+}
+export interface Config {
+    /**
+     * Destination server base url
+     *
+     * Require
+     */
+    server: string;
+    /**
+     * Access token
+     */
+    credential: string;
+    /**
+     * SourceId
+     */
+    sourceId: string;
+    /**
+     * log display filter
+     */
+    logs?: LogType[];
+    batch?: {
+        /**
+         * events and logs are sent to server in batches
+         * use interval to set the interval of flushing in mils
+         *
+         * Default to 5000mils
+         */
+        interval?: number;
+        /**
+         * The length of time to wait after a failure before retry
+         */
+        backoff?: number;
+        /**
+         * The number of retries before given up
+         *
+         * default to 3
+         */
+        limit?: number;
+    };
+    log?: {
+        /**
+         * if `true`, log primitive would be automatically captured
+         *
+         * Defaults to true
+         */
+        auto?: boolean;
+    };
+    event?: {
+        /**
+         * if `true`, events would be automatically captured
+         *
+         * On browser, page loads, clicks and mouse move events would be auto captured
+         *
+         * On server (Node), everything that goes through event emitter would be captured
+         *
+         * Defaults to true
+         */
+        auto?: boolean;
+        /**
+         * if defined, only events in the array would be captured
+         *
+         * events names can be build-in or custom
+         */
+        names?: string[];
+    };
+    debug?: boolean;
+}
+export interface IdentifyOptions {
+}
+export interface TrackOptions {
+}
+export interface MessageOptions {
+}
+export interface UploadOptions {
+}
+export interface SubmitOptions {
+}
+export interface ScheduleOptions {
+}
+export interface LogOptions {
+}
+export interface RegisterOptions {
+}
+export interface DispatchOptions {
+}
+export interface SendOptions {
+}
+export interface BaseResponseBody {
+    status: 'success' | 'error' | string;
+    title: string;
+    message: string;
+    data?: any;
+    meta?: any;
+    raw?: string;
+    headers?: any;
+    [key: string]: any;
+}
+export interface BaseRequestBody {
+    [key: string]: any;
+}
+export interface BaseEntity {
+    id?: string;
+    createdAt?: string;
+    updateAt?: string;
+    deletedAt?: string;
+    [key: string]: any;
+}
+export interface BaseRequestQuery {
+    query?: string;
+    page?: number;
+    from?: string;
+    to?: string;
+    perPage?: number;
+    relations?: string;
+    columns?: string;
+    [key: string]: any;
+}

package/events/index.d.ts

@@ -0,0 +1,4 @@
+import { EventData, IdentifyOptions, MessageOptions, TrackOptions } from '../common/utils/values';
+export declare const identify: (id: string, attributes: EventData, options?: IdentifyOptions) => void;
+export declare const track: (id: string, type: string, attributes: EventData, options?: TrackOptions) => void;
+export declare const message: (type: string, attributes: EventData, options?: MessageOptions) => void;

package/index.d.ts

@@ -0,0 +1,13 @@
+declare const events: {
+    identify: (id: string, attributes: import("./common/utils/values").EventData, options?: import("./common/utils/values").IdentifyOptions | undefined) => void;
+    track: (id: string, type: string, attributes: import("./common/utils/values").EventData, options?: import("./common/utils/values").TrackOptions | undefined) => void;
+    message: (type: string, attributes: import("./common/utils/values").EventData, options?: import("./common/utils/values").MessageOptions | undefined) => void;
+};
+/**
+ * Public APIs
+ */
+export { init } from './common/init/index';
+export * from './common/utils/values';
+export * from './platform/index';
+export * from './request/index';
+export { events };

package/index.js

@@ -0,0 +1,8 @@
+
+'use strict'
+
+if (process.env.NODE_ENV === 'production') {
+  module.exports = require('./jsx-polylog.cjs.production.min.js')
+} else {
+  module.exports = require('./jsx-polylog.cjs.development.js')
+}