@autentikar/step 2.0.0-alpha.9 → 2.1.0-alpha.11

package/dist/context.d.ts

@@ -1,16 +1,11 @@
+import { S as StorageItem, a as Step } from './index-vDg-Bas4.js';
+import 'file-type/core';
+import 'zod';
+
 interface Storage {
     save(name: string, content: Buffer, instance: string): Promise<StorageItem>;
     get(key: string): Promise<StorageItem | undefined>;
 }
-type PersistentType = "FILESYSTEM" | "MONGODB" | "S3" | "NFS" | "S3-MRAP" | "CDN";
-declare class StorageItem {
-    readonly path: string;
-    readonly type: PersistentType;
-    readonly buffer: Buffer;
-    readonly fileUrl: string;
-    constructor(path: string, type: PersistentType, buffer: Buffer, fileUrl: string);
-    getBase64(): string;
-}
 
 type KVKind = "INSTANCE" | "STEP";
 interface KV {
@@ -28,8 +23,10 @@ interface Preference {
 
 interface System {
     get<TValue = unknown>(name: string): Promise<TValue | undefined>;
+    stage(): string;
 }
 
+declare let step: Step;
 declare let params: Params;
 /** @deprecated use system. */
 declare let preference: Preference;
@@ -37,4 +34,4 @@ declare let system: System;
 declare let kv: KV;
 declare let asset: Storage;
 
-export { type KV, type Params, type Preference, type Storage, StorageItem, type System, asset, kv, params, preference, system };
+export { type KV, type Params, type Preference, Step, type Storage, type System, asset, kv, params, preference, step, system };

package/dist/context.js

@@ -20,29 +20,15 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/context.ts
 var context_exports = {};
 __export(context_exports, {
-  StorageItem: () => StorageItem,
   asset: () => asset,
   kv: () => kv,
   params: () => params,
   preference: () => preference,
+  step: () => step,
   system: () => system
 });
 module.exports = __toCommonJS(context_exports);
-
-// src/type/asset.ts
-var StorageItem = class {
-  constructor(path, type, buffer, fileUrl) {
-    this.path = path;
-    this.type = type;
-    this.buffer = buffer;
-    this.fileUrl = fileUrl;
-  }
-  getBase64() {
-    return this.buffer.toString("base64");
-  }
-};
-
-// src/context.ts
+var step;
 var params;
 var preference;
 var system;
@@ -50,10 +36,10 @@ var kv;
 var asset;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  StorageItem,
   asset,
   kv,
   params,
   preference,
+  step,
   system
 });

package/dist/index-vDg-Bas4.d.ts

@@ -0,0 +1,246 @@
+import * as file_type_core from 'file-type/core';
+import { z } from 'zod';
+
+interface Step {
+    params<TValue = unknown>(extend?: unknown): Promise<TValue | undefined>;
+    milestone(type: string, status: string, success: boolean): Promise<void>;
+    future(type: string, id: string, ttl: number): Promise<void>;
+    /** @deprecated Use addStepData*/
+    identity(organization_id: string, instance_id: string, link_session: string | undefined, identity: IdentityDto, data: StepIdentityData): Promise<any>;
+    addStepData(link_session: string | undefined, identity: IdentityDto, data: StepIdentityData): Promise<any>;
+    getStepData<T = StepIdentityData["type"]>(type: T, link_session: string | undefined): Promise<Extract<StepIdentityData, {
+        type: T;
+    }> | undefined>;
+    addVendorStat(params: {
+        vendor: string;
+        service: string;
+        amount?: number;
+        transaction_id: string;
+        meta?: Record<string, unknown>;
+    }): Promise<void>;
+}
+
+interface AutentikarRequestInit extends RequestInit {
+    host: string;
+    staging: Staging;
+    organization?: {
+        id: string;
+        alias: string;
+    };
+    step?: {
+        id: string;
+    };
+    flow?: {
+        id: string;
+        webhook: string | undefined;
+    };
+    instance?: {
+        id: string;
+    };
+    output?: Record<string, string>;
+    link_session: string | undefined;
+    params?: unknown;
+}
+declare class AutentikarRequest extends Request {
+    readonly organization?: AutentikarRequestInit["organization"];
+    readonly step?: AutentikarRequestInit["step"];
+    readonly instance?: AutentikarRequestInit["instance"];
+    readonly staging?: Staging;
+    readonly link_session: string | undefined;
+    readonly params?: unknown;
+    readonly output?: Record<string, string>;
+    readonly host?: string;
+    readonly flow: {
+        id: string;
+        webhook: string | undefined;
+    } | undefined;
+    constructor(input: RequestInfo, init?: AutentikarRequestInit);
+}
+interface AutentikarResponseInit extends ResponseInit {
+    success: boolean;
+    akStatus: string;
+    data: {
+        output: unknown;
+    } & Record<string, unknown>;
+    next: string | undefined;
+    error?: string;
+}
+declare class AutentikarResponse extends Response {
+    readonly success: boolean | undefined;
+    readonly akStatus: string | undefined;
+    readonly data: ({
+        output: unknown;
+    } & Record<string, unknown>) | undefined;
+    readonly next: string | undefined;
+    readonly error: string | undefined;
+    constructor(bodyInit?: BodyInit | null, init?: AutentikarResponseInit);
+    static json(data: any, init: AutentikarResponseInit): AutentikarResponse;
+}
+
+type StepIdentityData = {
+    type: "SOURCE_FACE_2D";
+    face: string;
+} | {
+    type: "DOCUMENT";
+    doc_type: IdentityDto["doc_type"];
+    images: {
+        front: string;
+        back?: string;
+    };
+} | {
+    type: "CARD";
+    doc_type: IdentityDto["doc_type"];
+    images: {
+        face: string;
+        front: string;
+        back?: string;
+    };
+} | {
+    type: "FACE";
+    provider: "FACETEC" | "IDENTY" | "2D" | ({} & string);
+    audit_low?: string;
+    audit: string;
+    map?: string;
+} | {
+    type: "EMAIL";
+    email: string;
+} | {
+    type: "CELLPHONE";
+    cellphone: string;
+    country?: string;
+} | {
+    type: "CONSENT";
+    value: "OWN" | "AUTENTIKAR" | "NONE";
+    text?: string;
+    consent_id: string;
+};
+declare class StepRequest implements Step {
+    private step;
+    constructor(params: Step);
+    addStepData(link_session: string | undefined, identity: IdentityDto, data: StepIdentityData): Promise<any>;
+    getStepData<T = StepIdentityData["type"]>(type: T, link_session: string | undefined): Promise<Extract<StepIdentityData, {
+        type: T;
+    }> | undefined>;
+    addVendorStat(params: {
+        vendor: string;
+        service: string;
+        amount?: number;
+        transaction_id: string;
+        meta?: Record<string, unknown>;
+    }): Promise<void>;
+    future(type: string, id: string, ttl: number): Promise<void>;
+    milestone(type: string, status: string, success: boolean): Promise<void>;
+    params<TValue = unknown>(extend?: unknown): Promise<TValue | undefined>;
+    identity(organization_id: string, instance_id: string, link_session: string | undefined, identity: IdentityDto, data: StepIdentityData): Promise<any>;
+}
+declare const AppEnvironmentsSchema: z.ZodObject<{
+    STAGING: z.ZodEnum<["LOCAL", "QA", "PROD"]>;
+    STEP_TYPE: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    STAGING: "LOCAL" | "QA" | "PROD";
+    STEP_TYPE: string;
+}, {
+    STAGING: "LOCAL" | "QA" | "PROD";
+    STEP_TYPE: string;
+}>;
+declare const IdentitySchemaDto: z.ZodObject<{
+    country: z.ZodString;
+    doc_type: z.ZodString;
+    id_num: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    country: string;
+    doc_type: string;
+    id_num: string;
+}, {
+    country: string;
+    doc_type: string;
+    id_num: string;
+}>;
+type IdentityDto = z.infer<typeof IdentitySchemaDto>;
+type AppEnvironments = z.infer<typeof AppEnvironmentsSchema>;
+type Staging = AppEnvironments["STAGING"];
+type MethodContextOrganization = {
+    id: string;
+};
+type MethodContextFlow = {
+    id: string;
+    webhook: string | undefined;
+};
+type MethodContextInstance = {
+    id: string;
+};
+type MethodContextStep = {
+    params: unknown;
+};
+type PersistentType = "FILESYSTEM" | "MONGODB" | "S3" | "NFS" | "S3-MRAP" | "CDN";
+declare class StorageItem {
+    readonly path: string;
+    readonly type: PersistentType;
+    readonly buffer: Buffer;
+    readonly fileUrl: string;
+    readonly contentType: string | undefined;
+    constructor(path: string, type: PersistentType, buffer: Buffer, fileUrl: string, contentType: string | undefined);
+    getBase64(): string;
+    getContenType(): Promise<file_type_core.MimeType | "unknown">;
+}
+type Method = (req: AutentikarRequest) => Promise<AutentikarResponse>;
+type Resource = (req: AutentikarRequest) => Promise<AutentikarResponse>;
+type AppEnvVariables = {
+    instance: {
+        id: string;
+        session: string | undefined;
+    };
+};
+type AppEnv = {
+    Bindings: AppEnvironments;
+    Variables: AppEnvVariables;
+};
+declare class StepDefinition {
+    readonly id: string;
+    readonly type: string;
+    readonly prev_step: string;
+    readonly user_interaction: boolean;
+    readonly return_result: boolean;
+    readonly end_after_processing: undefined | {
+        dispatch: "NO";
+    } | {
+        dispatch: "AUTO";
+    };
+    readonly params: Record<string, string> | undefined;
+    readonly output: Record<string, string> | undefined;
+    readonly milestone: undefined | {
+        cloud_hidden?: boolean;
+        call_webhook?: boolean;
+    };
+    constructor(id: string, type: string, prev_step: string, user_interaction: boolean, return_result: boolean, end_after_processing: undefined | {
+        dispatch: "NO";
+    } | {
+        dispatch: "AUTO";
+    }, params: Record<string, string> | undefined, output: Record<string, string> | undefined, milestone: undefined | {
+        cloud_hidden?: boolean;
+        call_webhook?: boolean;
+    });
+}
+declare class StepInstance {
+    readonly id: string;
+    readonly expires_at: number | undefined;
+    constructor(id: string, expires_at: number | undefined);
+    isExpired(): boolean | 0 | undefined;
+}
+declare class FlowContext {
+    readonly id: string;
+    readonly webhook: string | undefined;
+    constructor(id: string, webhook: string | undefined);
+}
+declare class StepContext {
+    readonly org: string;
+    readonly flow: FlowContext;
+    readonly step: StepDefinition;
+    readonly instance: StepInstance;
+    readonly expires_at: number | undefined;
+    readonly params: unknown;
+    constructor(org: string, flow: FlowContext, step: StepDefinition, instance: StepInstance, expires_at: number | undefined, params: unknown);
+    isExpired(): boolean | 0 | undefined;
+}
+
+export { AutentikarRequest as A, FlowContext as F, IdentitySchemaDto as I, type MethodContextOrganization as M, type PersistentType as P, type Resource as R, StorageItem as S, type Step as a, AutentikarResponse as b, type StepIdentityData as c, StepRequest as d, type IdentityDto as e, type AppEnvironments as f, type Staging as g, type MethodContextFlow as h, type MethodContextInstance as i, type MethodContextStep as j, type Method as k, type AppEnvVariables as l, type AppEnv as m, StepDefinition as n, StepInstance as o, StepContext as p };

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+import 'file-type/core';
+import 'zod';
+export { m as AppEnv, l as AppEnvVariables, f as AppEnvironments, A as AutentikarRequest, b as AutentikarResponse, F as FlowContext, e as IdentityDto, I as IdentitySchemaDto, k as Method, h as MethodContextFlow, i as MethodContextInstance, M as MethodContextOrganization, j as MethodContextStep, P as PersistentType, R as Resource, g as Staging, p as StepContext, n as StepDefinition, c as StepIdentityData, o as StepInstance, d as StepRequest, S as StorageItem } from './index-vDg-Bas4.js';

package/dist/index.js

@@ -0,0 +1,217 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  AutentikarRequest: () => AutentikarRequest,
+  AutentikarResponse: () => AutentikarResponse,
+  FlowContext: () => FlowContext,
+  IdentitySchemaDto: () => IdentitySchemaDto,
+  StepContext: () => StepContext,
+  StepDefinition: () => StepDefinition,
+  StepInstance: () => StepInstance,
+  StepRequest: () => StepRequest,
+  StorageItem: () => StorageItem
+});
+module.exports = __toCommonJS(src_exports);
+var import_zod = require("zod");
+var import_file_type = __toESM(require("file-type"));
+
+// src/autentikar-fetch.ts
+var AutentikarRequest = class extends Request {
+  organization;
+  step;
+  instance;
+  staging;
+  link_session;
+  params;
+  output;
+  host;
+  flow;
+  constructor(input, init) {
+    super(input, init);
+    this.organization = init?.organization;
+    this.step = init?.step;
+    this.instance = init?.instance;
+    this.staging = init?.staging;
+    this.link_session = init?.link_session;
+    this.params = init?.params;
+    this.output = init?.output;
+    this.host = init?.host;
+    this.flow = init?.flow;
+  }
+};
+var AutentikarResponse = class _AutentikarResponse extends Response {
+  success;
+  akStatus;
+  data;
+  next;
+  error;
+  constructor(bodyInit, init) {
+    super(bodyInit, init);
+    this.success = init?.success;
+    this.akStatus = init?.akStatus;
+    this.data = init?.data;
+    this.next = init?.next;
+    this.error = init?.error;
+  }
+  static json(data, init) {
+    const body = JSON.stringify(data);
+    const headers = new Headers(init.headers || {});
+    headers.set("Content-Type", "application/json");
+    return new _AutentikarResponse(body, {
+      ...init,
+      headers
+    });
+  }
+};
+
+// src/index.ts
+var StepRequest = class {
+  step;
+  constructor(params) {
+    this.step = params;
+  }
+  async addStepData(link_session, identity, data) {
+    return this.step.addStepData(link_session, identity, data);
+  }
+  async getStepData(type, link_session) {
+    return this.step.getStepData(type, link_session);
+  }
+  addVendorStat(params) {
+    return this.step.addVendorStat(params);
+  }
+  future(type, id, ttl) {
+    return this.step.future(type, id, ttl);
+  }
+  milestone(type, status, success) {
+    return this.step.milestone(type, status, success);
+  }
+  params(extend) {
+    return this.step.params(extend);
+  }
+  identity(organization_id, instance_id, link_session, identity, data) {
+    return this.step.identity(
+      organization_id,
+      instance_id,
+      link_session,
+      identity,
+      data
+    );
+  }
+};
+var AppEnvironmentsSchema = import_zod.z.object({
+  STAGING: import_zod.z.enum(["LOCAL", "QA", "PROD"]),
+  STEP_TYPE: import_zod.z.string()
+});
+var IdentitySchemaDto = import_zod.z.object({
+  country: import_zod.z.string(),
+  doc_type: import_zod.z.string(),
+  id_num: import_zod.z.string()
+});
+async function getContentTypeFromBuffer(buffer) {
+  const type = await import_file_type.default.fromBuffer(buffer);
+  if (type) {
+    return type.mime;
+  } else {
+    return "unknown";
+  }
+}
+var StorageItem = class {
+  constructor(path, type, buffer, fileUrl, contentType) {
+    this.path = path;
+    this.type = type;
+    this.buffer = buffer;
+    this.fileUrl = fileUrl;
+    this.contentType = contentType;
+  }
+  getBase64() {
+    return this.buffer.toString("base64");
+  }
+  getContenType() {
+    return getContentTypeFromBuffer(this.buffer);
+  }
+};
+var StepDefinition = class {
+  constructor(id, type, prev_step, user_interaction, return_result, end_after_processing, params, output, milestone) {
+    this.id = id;
+    this.type = type;
+    this.prev_step = prev_step;
+    this.user_interaction = user_interaction;
+    this.return_result = return_result;
+    this.end_after_processing = end_after_processing;
+    this.params = params;
+    this.output = output;
+    this.milestone = milestone;
+  }
+};
+var StepInstance = class {
+  constructor(id, expires_at) {
+    this.id = id;
+    this.expires_at = expires_at;
+  }
+  // public isInvalid() {
+  //   return this.expires_at && this.expires_at < Date.now();
+  // }
+  isExpired() {
+    return this.expires_at && this.expires_at < Date.now();
+  }
+};
+var FlowContext = class {
+  constructor(id, webhook) {
+    this.id = id;
+    this.webhook = webhook;
+  }
+};
+var StepContext = class {
+  constructor(org, flow, step, instance, expires_at, params) {
+    this.org = org;
+    this.flow = flow;
+    this.step = step;
+    this.instance = instance;
+    this.expires_at = expires_at;
+    this.params = params;
+  }
+  isExpired() {
+    return this.expires_at && this.expires_at < Date.now();
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AutentikarRequest,
+  AutentikarResponse,
+  FlowContext,
+  IdentitySchemaDto,
+  StepContext,
+  StepDefinition,
+  StepInstance,
+  StepRequest,
+  StorageItem
+});

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@autentikar/step",
-  "version": "2.0.0-alpha.9",
+  "version": "2.1.0-alpha.11",
   "description": "",
   "files": [
     "dist"
   ],
   "exports": {
+    ".": "./dist/index.js",
     "./context": "./dist/context.js",
     "./package.json": "./package.json"
   },
   "typesVersions": {
     "*": {
+      ".": [
+        "./dist/index.d.ts"
+      ],
       "context": [
         "./dist/context.d.ts"
       ]
@@ -28,5 +32,9 @@
     "@types/node": "^20.11.5",
     "tsup": "^8.0.1",
     "typescript": "^5.2.2"
+  },
+  "dependencies": {
+    "file-type": "16.5.3",
+    "zod": "^3.22.4"
   }
 }