@shaxpir/duiduidui-models 1.0.0

package/README.md

@@ -0,0 +1 @@
+# duiduidui-models

package/decs.d.ts

@@ -0,0 +1,87 @@
+declare module '@shaxpir/sharedb/lib/client' {
+    interface Error {
+        code: number;
+        message: string;
+        stack: string;
+    }
+    interface Types {
+        register: (type: any) => void;
+        map: { [key: string]: any };
+    }
+    const types: Types;
+    class Agent<TCustom = any> {
+        backend: any;
+        stream: any;
+        custom: any;
+        send(message: any): void;
+    }
+    class Connection {
+        constructor(ws: any, options?:any);
+    
+        // This direct reference from connection to agent is not used internal to
+        // ShareDB, but it is handy for server-side only user code that may cache
+        // state on the agent and read it in middleware
+        agent: Agent | null;
+    
+        collections: Record<string, Record<string, Doc>>;
+        queries: Record<string, any>;
+    
+        seq: number;
+        id: string | null; // Equals agent.src on the server
+        nextQueryId: number;
+        nextSnapshotRequestId: number;
+    
+        state: string;
+        debug: boolean;
+    
+        ping():void;
+        close(): void;
+        get(collectionName: string, documentID: string): Doc;
+        isDocInInventory(collection: string, id: string, minVersion?: string|number):boolean;
+        forEachPendingDocCollectionId(callback:(collection: string, id: string) => void):void;
+        createFetchQuery<T = any>(collectionName: string, query: any, options?: {results?: Array<Doc<T>>} | null, callback?: (err: Error, results: Array<Doc<T>>) => void): any;
+        createSubscribeQuery<T = any>(collectionName: string, query: any, options?: {results?: Array<Doc<T>>} | null, callback?: (err: Error, results: Array<Doc<T>>) => void): any;
+        fetchSnapshot(collection: string, id: string, version: number, callback: (error: Error, snapshot: any) => void): void;
+        fetchSnapshotByTimestamp(collection: string, id: string, timestamp: number, callback: (error: Error, snapshot: any) => void): void;
+        getPresence(channel: string): any;
+        getDocPresence(collection: string, id: string): any;
+        on(eventName: string, listener: (error: Error) => void): void;
+        off(eventName: string, listener: (error: Error) => void): void;
+    }
+    class Doc<T = any> {
+        connection: Connection;
+        type: any;
+        id: string;
+        collection: string;
+        data: T;
+        version: any;
+        subscribed: boolean;
+        preventCompose: boolean;
+        paused: boolean;
+        submitSource: boolean;
+
+        on: (eventName:string, callback:any) => void;
+        off: (eventName:string, callback:any) => void;
+    
+        fetch: (callback?: (err: Error) => void) => void;
+        subscribe: (callback?: (err: Error) => void) => void;
+        unsubscribe: (callback?: (err: Error) => void) => void;
+    
+        ingestSnapshot(snapshot: any, callback?: any): void;
+        destroy(callback?: any): void;
+        create(data: any, callback?: any): void;
+        create(data: any, type?: any, callback?: any): void;
+        create(data: any, type?: any, options?: any, callback?: any): void;
+        submitOp(data: any, options?: any, callback?: any): void;
+        del(options: any, callback?: (err: Error) => void): void;
+        whenNothingPending(callback: () => void): void;
+        hasPending(): boolean;
+        hasWritePending(): boolean;
+        pause(): void;
+        resume(): void;
+        flush(): void;
+
+        ensureDocHasData(callback?: any): void;
+        ensureDocHasRecentData(minVersion:string|number, callback?: any): void;
+    }
+}

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export * from './models';
+export * from './repo';
+export * from './util';

package/dist/index.js

@@ -0,0 +1,20 @@
+"use strict";
+// created from 'create-ts-index'
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./models"), exports);
+__exportStar(require("./repo"), exports);
+__exportStar(require("./util"), exports);

package/dist/models/OutboundMessage.d.ts

@@ -0,0 +1,18 @@
+import { CompactDateTime } from "./content/Time";
+export declare enum OutboundChannel {
+    EMAIL = "EMAIL"
+}
+export interface OutboundMessage {
+    id: string;
+    at_utc_time: CompactDateTime;
+    user_id: string;
+    campaign: string;
+    channel: OutboundChannel;
+    template: string;
+    recipient: string;
+    dryrun: boolean;
+    params: any;
+}
+export declare class OutboundMessageModel {
+    static create(userId: string, template: string, recipient: string, params: any): OutboundMessage;
+}

package/dist/models/OutboundMessage.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutboundMessageModel = exports.OutboundChannel = void 0;
+const Time_1 = require("./content/Time");
+var OutboundChannel;
+(function (OutboundChannel) {
+    OutboundChannel["EMAIL"] = "EMAIL";
+})(OutboundChannel || (exports.OutboundChannel = OutboundChannel = {}));
+class OutboundMessageModel {
+    static create(userId, template, recipient, params) {
+        params.email = recipient;
+        return {
+            "id": null,
+            "at_utc_time": Time_1.Time.utc(),
+            "user_id": userId,
+            "campaign": null,
+            "channel": OutboundChannel.EMAIL,
+            "template": template,
+            "recipient": recipient,
+            "dryrun": false,
+            "params": params
+        };
+    }
+}
+exports.OutboundMessageModel = OutboundMessageModel;

package/dist/models/content/Activity.d.ts

@@ -0,0 +1,10 @@
+import { ContentId } from "./Content";
+import { ContentKind } from "./ContentKind";
+import { CompactDateTime } from "./Time";
+export interface Activity {
+    kind: ContentKind;
+    id: ContentId;
+    before: CompactDateTime;
+    after: CompactDateTime;
+    word_count?: number;
+}

package/dist/models/content/Activity.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/models/content/ArrayView.d.ts

@@ -0,0 +1,26 @@
+import { JsonPath } from "../markup/Operation";
+import { Content } from "./Content";
+export declare class ArrayView<T> {
+    protected content: Content;
+    protected path: JsonPath;
+    constructor(content: Content, path: JsonPath);
+    private get root();
+    get length(): number;
+    get values(): T[];
+    get(idx: number): T;
+    indexOf(value: any): number;
+    includes(value: any): boolean;
+    firstIndexWhere(predicate: (value: T) => boolean): number;
+    removeFirstWhere(predicate: (value: T) => boolean): void;
+    removeAllWhere(predicate: (value: T) => boolean): void;
+    forEach(callback: (idx: number, value: T) => void): void;
+    unshift(value: T): void;
+    push(value: T): void;
+    insert(idx: number, value: T): void;
+    remove(value: T): void;
+    removeAt(index: number): void;
+    move(originIndex: number, destinationIndex: number): void;
+    removeObjectPropertyAtIndex(index: number, fieldName: string): void;
+    setObjectValueAtIndex(index: number, fieldName: string, newValue: any): void;
+    editObjectTextValueAtIndex(index: number, fieldName: string, newValue: string): void;
+}

package/dist/models/content/ArrayView.js

@@ -0,0 +1,174 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArrayView = void 0;
+const Struct_1 = require("../../util/Struct");
+const Operation_1 = require("../markup/Operation");
+class ArrayView {
+    constructor(content, path) {
+        this.content = content;
+        this.path = path;
+    }
+    get root() {
+        this.content.checkDisposed("ArrayView.root");
+        return Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, this.path);
+    }
+    get length() {
+        this.content.checkDisposed("ArrayView.length");
+        return this.root.length;
+    }
+    get values() {
+        this.content.checkDisposed("ArrayView.values");
+        return Struct_1.Struct.clone(this.root);
+    }
+    get(idx) {
+        this.content.checkDisposed("ArrayView.get");
+        return Struct_1.Struct.clone(this.root[idx]);
+    }
+    indexOf(value) {
+        this.content.checkDisposed("ArrayView.indexOf");
+        const array = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, this.path);
+        for (let i = 0; i < array.length; i++) {
+            if (array[i] == value) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    includes(value) {
+        this.content.checkDisposed("ArrayView.includes");
+        const array = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, this.path);
+        for (let i = 0; i < array.length; i++) {
+            if (array[i] == value) {
+                return true;
+            }
+        }
+        return false;
+    }
+    firstIndexWhere(predicate) {
+        this.content.checkDisposed("ArrayView.firstIndexWhere");
+        const array = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, this.path);
+        for (let i = 0; i < array.length; i++) {
+            if (predicate(array[i])) {
+                return i;
+            }
+        }
+        return -1;
+    }
+    removeFirstWhere(predicate) {
+        this.content.checkDisposed("ArrayView.removeFirstWhere");
+        const index = this.firstIndexWhere(predicate);
+        this.removeAt(index);
+    }
+    removeAllWhere(predicate) {
+        this.content.checkDisposed("ArrayView.removeAllWhere");
+        let foundMatch = false;
+        const batch = new Operation_1.BatchOperation(this.content);
+        const array = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, this.path);
+        for (let i = 0; i < array.length; i++) {
+            if (predicate(array[i])) {
+                const pathToElement = Struct_1.Struct.clone(this.path);
+                pathToElement.push(i);
+                batch.removeValueAtPath(pathToElement);
+                foundMatch = true;
+            }
+        }
+        if (foundMatch) {
+            batch.commit();
+        }
+    }
+    forEach(callback) {
+        this.content.checkDisposed("ArrayView.forEach");
+        const array = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, this.path);
+        for (let i = 0; i < array.length; i++) {
+            callback(i, array[i]);
+        }
+    }
+    unshift(value) {
+        this.content.checkDisposed("ArrayView.unshift");
+        const batch = new Operation_1.BatchOperation(this.content);
+        batch.unshiftIntoArray(this.path, value);
+        batch.commit();
+    }
+    push(value) {
+        this.content.checkDisposed("ArrayView.push");
+        const batch = new Operation_1.BatchOperation(this.content);
+        batch.pushIntoArray(this.path, value);
+        batch.commit();
+    }
+    insert(idx, value) {
+        this.content.checkDisposed("ArrayView.insert");
+        if (idx == this.length) {
+            this.push(value);
+        }
+        else {
+            const batch = new Operation_1.BatchOperation(this.content);
+            batch.insertIntoArray(this.path, idx, value);
+            batch.commit();
+        }
+    }
+    remove(value) {
+        this.content.checkDisposed("ArrayView.remove");
+        const index = this.indexOf(value);
+        if (index >= 0) {
+            this.removeAt(index);
+        }
+    }
+    removeAt(index) {
+        this.content.checkDisposed("ArrayView.removeAt");
+        const pathToElement = Struct_1.Struct.clone(this.path);
+        pathToElement.push(index);
+        const batch = new Operation_1.BatchOperation(this.content);
+        batch.removeValueAtPath(pathToElement);
+        batch.commit();
+    }
+    move(originIndex, destinationIndex) {
+        this.content.checkDisposed("ArrayView.move");
+        if (originIndex != destinationIndex) {
+            const originPath = Struct_1.Struct.clone(this.path);
+            const destinationPath = Struct_1.Struct.clone(this.path);
+            originPath.push(originIndex);
+            destinationPath.push(destinationIndex);
+            const batch = new Operation_1.BatchOperation(this.content);
+            batch.move(originPath, destinationPath);
+            batch.commit();
+        }
+    }
+    removeObjectPropertyAtIndex(index, fieldName) {
+        this.content.checkDisposed("ArrayView.setObjectValueAtIndex");
+        const pathToElement = Struct_1.Struct.clone(this.path);
+        pathToElement.push(index);
+        const element = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, pathToElement);
+        if (element.hasOwnProperty(fieldName)) {
+            const pathToProperty = Struct_1.Struct.clone(this.path);
+            pathToProperty.push(fieldName);
+            const batch = new Operation_1.BatchOperation(this.content);
+            batch.removeValueAtPath(pathToProperty);
+            batch.commit();
+        }
+    }
+    setObjectValueAtIndex(index, fieldName, newValue) {
+        this.content.checkDisposed("ArrayView.setObjectValueAtIndex");
+        const pathToElement = Struct_1.Struct.clone(this.path);
+        pathToElement.push(index);
+        pathToElement.push(fieldName);
+        const prevValue = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, pathToElement);
+        if (!Struct_1.Struct.equals(prevValue, newValue)) {
+            const batch = new Operation_1.BatchOperation(this.content);
+            batch.setPathValue(pathToElement, newValue);
+            batch.commit();
+        }
+    }
+    editObjectTextValueAtIndex(index, fieldName, newValue) {
+        this.content.checkDisposed("ArrayView.editObjectTextValueAtIndex");
+        const pathToElement = Struct_1.Struct.clone(this.path);
+        pathToElement.push(index);
+        pathToElement.push(fieldName);
+        const prevValue = Operation_1.JsonPathSelect.getValueAtPath(this.content.doc, pathToElement);
+        if (!Struct_1.Struct.equals(prevValue, newValue)) {
+            const batch = new Operation_1.BatchOperation(this.content);
+            batch.editPathText(pathToElement, newValue);
+            batch.commit();
+        }
+    }
+}
+exports.ArrayView = ArrayView;

package/dist/models/content/Billing.d.ts

@@ -0,0 +1,144 @@
+/// <reference path="../../../decs.d.ts" />
+import { Doc } from '@shaxpir/sharedb/lib/client';
+import { ShareSync } from '../../repo/ShareSync';
+import { ArrayView } from './ArrayView';
+import { Content, ContentBody, ContentId, ContentMeta } from "./Content";
+import { CompactDateTime, MultiTime } from './Time';
+export interface CreditCardHarvest {
+    name: string;
+    number: string;
+    cvc: string;
+    exp_month: string;
+    exp_year: string;
+}
+export interface CreditCard {
+    name: string;
+    brand: string;
+    last4: string;
+    exp_month: string;
+    exp_year: string;
+    country: string;
+    funding: string;
+    wallet?: string;
+}
+export interface TransactionPayload {
+    at_utc_time?: CompactDateTime;
+    topic: TransactionTopic;
+    details?: any;
+}
+export declare enum TransactionTopic {
+    START_7_DAY_TRIAL = "START_7_DAY_TRIAL",
+    APPLY_COUPON = "APPLY_COUPON",
+    PAYMENT_SUCCESS = "PAYMENT_SUCCESS",
+    PAYMENT_FAIL = "PAYMENT_FAIL",
+    CANCEL_SUBSCRIPTION = "CANCEL_SUBSCRIPTION",
+    RESTART_SUBSCRIPTION = "RESTART_SUBSCRIPTION"
+}
+export declare enum Interval {
+    MONTHLY = "MONTHLY",
+    ANNUAL = "ANNUAL"
+}
+export declare enum ProductLevel {
+    FREE = "FREE",
+    BASIC = "BASIC",
+    PRO = "PRO"
+}
+export interface BillingProduct {
+    id: string;
+    name: string;
+    level: ProductLevel;
+}
+export interface BillingPrice {
+    id: string;
+    name: string;
+    amount: number;
+    interval: Interval;
+    product_id: string;
+    trial_days: number;
+}
+export interface BillingPlan {
+    id: string;
+    name: string;
+    amount: number;
+    level: ProductLevel;
+    interval: Interval;
+    trial_days: number;
+}
+export interface ProductCatalogConfig {
+    products: BillingProduct[];
+    prices: BillingPrice[];
+    plans: BillingPlan[];
+}
+export declare class ProductCatalog {
+    private productsById;
+    private pricesById;
+    private plansById;
+    constructor(config: ProductCatalogConfig);
+    getProductById(id: string): BillingProduct;
+    getPriceById(id: string): BillingPrice;
+    getPlanById(id: string): BillingPlan;
+    getProductsByPredicate(predicate: (product: BillingProduct) => boolean): BillingProduct[];
+    getPricesByPredicate(predicate: (price: BillingPrice) => boolean): BillingPrice[];
+    getPlansByPredicate(predicate: (plan: BillingPlan) => boolean): BillingPlan[];
+}
+export declare enum PaymentStatus {
+    PRE_TRIAL = "PRE_TRIAL",
+    IN_TRIAL = "IN_TRIAL",
+    PAID = "PAID",
+    UNPAID = "UNPAID",
+    CANCELLED = "CANCELLED"
+}
+export interface BillingBody extends ContentBody {
+    meta: ContentMeta;
+    payload: BillingPayload;
+}
+export interface BillingPayload {
+    payment_status: PaymentStatus;
+    paid_until: CompactDateTime;
+    stripe_customer_id: string;
+    stripe_payment_method_id?: string;
+    stripe_payment_method_type?: string;
+    transactions: TransactionPayload[];
+    credit_card?: CreditCard;
+    product_id?: string;
+    price_id?: string;
+}
+export declare class Billing extends Content {
+    private _transactionsView;
+    constructor(doc: Doc, shouldAcquire: boolean, shareSync: ShareSync);
+    get payload(): BillingPayload;
+    static makeBillingId(userId: ContentId): ContentId;
+    static create(userId: ContentId, payload: BillingPayload, createdAt?: MultiTime): Billing;
+    isSubscribedToPricedProduct(): boolean;
+    get priceId(): string;
+    setPriceId(value: string): void;
+    get productId(): string;
+    setProductId(value: string): void;
+    get paidUntil(): CompactDateTime;
+    setPaidUntil(value: CompactDateTime): void;
+    get paymentStatus(): PaymentStatus;
+    setPaymentStatus(value: PaymentStatus): void;
+    get stripeCustomerId(): string;
+    setStripeCustomerId(value: string): void;
+    get stripePaymentMethodId(): string;
+    setStripePaymentMethodId(value: string): void;
+    get stripePaymentMethodType(): string;
+    setStripePaymentMethodType(value: string): void;
+    get creditCard(): CreditCard;
+    setCreditCard(value: CreditCard): void;
+    get transactions(): ArrayView<TransactionPayload>;
+    get sortedTransactions(): TransactionPayload[];
+    getLastTransaction(): TransactionPayload;
+    getLastPaymentTransaction(): TransactionPayload;
+    getActiveUserCoupon(): any;
+    daysPastDue(): number;
+    didLastPaymentFail(): boolean;
+    didLastPaymentSucceed(): boolean;
+    findTransactionByTopic(topic: TransactionTopic): TransactionPayload;
+    cancel(): void;
+    restartPlan(plan: string, paidUntilEpochSeconds: number): void;
+    restartPricedProduct(productId: string, priceId: string, paidUntilEpochSeconds: number): void;
+    static findByStripeCustomerId(stripeCustomerId: string): Promise<Billing[]>;
+    static describeCoupon(coupon: any): string;
+    static normalizeCreditCardBrand(brand: string): string;
+}