@appconda/sdk 1.0.194 → 1.0.410

package/src/enums/subscriptions/PricingModel.ts

@@ -0,0 +1,14 @@
+import { z } from "zod";
+
+export enum PricingModel {
+  FLAT_RATE,
+  PER_SEAT,
+  USAGE_BASED,
+  FLAT_RATE_USAGE_BASED,
+  ONCE,
+  ALL,
+}
+
+export const ZPricingModel = z.nativeEnum(PricingModel);
+
+export type TPricingModel = z.infer<typeof ZPricingModel>;

package/src/enums/subscriptions/SubscriptionBillingPeriod.ts

@@ -0,0 +1,15 @@
+import { z } from "zod";
+
+export enum SubscriptionBillingPeriod {
+  ONCE,
+  DAILY,
+  WEEKLY,
+  MONTHLY,
+  YEARLY,
+}
+
+
+export const ZSubscriptionBillingPeriod = z.nativeEnum(SubscriptionBillingPeriod);
+
+
+export type TSubscriptionBillingPeriod = z.infer<typeof ZSubscriptionBillingPeriod>;

package/src/enums/subscriptions/SubscriptionFeatureLimitType.ts

@@ -0,0 +1,16 @@
+import { z } from "zod";
+
+// TypeScript Enum
+export enum SubscriptionFeatureLimitType {
+  NOT_INCLUDED,
+  INCLUDED,
+  MONTHLY,
+  MAX,
+  UNLIMITED,
+}
+
+// Zod şeması ile Enum doğrulama
+export const ZSubscriptionFeatureLimitType = z.nativeEnum(SubscriptionFeatureLimitType);
+
+// Tür çıkarımı
+export type TSubscriptionFeatureLimitType = z.infer<typeof ZSubscriptionFeatureLimitType>;

package/src/enums/subscriptions/SubscriptionPriceType.ts

@@ -0,0 +1,10 @@
+import { z } from "zod";
+
+export enum SubscriptionPriceType {
+  ONE_TIME,
+  RECURRING,
+}
+
+export const ZSubscriptionPriceType = z.nativeEnum(SubscriptionPriceType);
+
+export type TSubscriptionPriceType = z.infer<typeof ZSubscriptionPriceType>;

package/src/enums/tenants/LinkedAccountStatus.ts

@@ -0,0 +1,5 @@
+export enum LinkedAccountStatus {
+  PENDING,
+  LINKED,
+  REJECTED,
+}

package/src/enums/tenants/TenantUserJoined.ts

@@ -0,0 +1,6 @@
+export enum TenantUserJoined {
+  CREATOR,
+  JOINED_BY_INVITATION,
+  JOINED_BY_LINK,
+  JOINED_BY_PUBLIC_URL,
+}

package/src/enums/tenants/TenantUserStatus.ts

@@ -0,0 +1,6 @@
+export enum TenantUserStatus {
+  PENDING_INVITATION,
+  PENDING_ACCEPTANCE,
+  ACTIVE,
+  INACTIVE,
+}

package/src/enums/tenants/TenantUserType.ts

@@ -0,0 +1,5 @@
+export enum TenantUserType {
+  OWNER,
+  ADMIN,
+  MEMBER,
+}

package/src/enums/user-usage-range.ts

@@ -0,0 +1,5 @@
+export enum UserUsageRange {
+    TwentyFourHours = '24h',
+    ThirtyDays = '30d',
+    NinetyDays = '90d',
+}

package/src/getAppcondaClient.ts

@@ -0,0 +1,75 @@
+import { Client } from "./client";
+
+function getPortAndHostname(urlString: string): { hostname: string; port: string; protocol: string } {
+    try {
+        const url = new URL(urlString);
+        return {
+            hostname: url.hostname,
+            port: url.port || (url.protocol === 'https:' ? '443' : '80'), // Default ports if not specified
+            protocol: url.protocol
+        };
+    } catch (error) {
+        console.error('Invalid URL:', error);
+        return { hostname: '', port: '', protocol: '' };
+    }
+}
+
+const APPCONDA_ENDPOINT = 'http://localhost/v1';
+
+export async function getAppcondaClient() {
+
+    let url;
+    if (APPCONDA_ENDPOINT) {
+        url = APPCONDA_ENDPOINT;
+    } else if (typeof window !== 'undefined') {
+        const hostInfo = getPortAndHostname(window.location.href);
+        if (hostInfo.port) {
+            url = `${hostInfo.protocol}//${hostInfo.hostname}:${hostInfo.port}/v1`
+        } else {
+            url = `${hostInfo.protocol}//${hostInfo.hostname}/v1`
+        }
+    } else {
+        url = APPCONDA_ENDPOINT || 'http://appconda/v1'
+    }
+
+    /*  if (ApplicationConfig.Port == null) {
+         url = `${ApplicationConfig.Protocol}://${ApplicationConfig.Domain}:${ApplicationConfig.Port}/v1`
+     } else {
+           url = `${ApplicationConfig.Protocol}://${ApplicationConfig.Domain}/v1`
+     }  */
+    const adminClient = new Client()
+        .setEndpoint(url) // Your API Endpoint
+        .setProject('console');
+
+    return adminClient
+
+}
+
+export  function getAppcondaClientSync() {
+
+    let url;
+    if (APPCONDA_ENDPOINT) {
+        url = APPCONDA_ENDPOINT;
+    } else if (typeof window !== 'undefined') {
+        const hostInfo = getPortAndHostname(window.location.href);
+        if (hostInfo.port) {
+            url = `${hostInfo.protocol}//${hostInfo.hostname}:${hostInfo.port}/v1`
+        } else {
+            url = `${hostInfo.protocol}//${hostInfo.hostname}/v1`
+        }
+    } else {
+        url = APPCONDA_ENDPOINT || 'http://appconda/v1'
+    }
+
+    /*  if (ApplicationConfig.Port == null) {
+         url = `${ApplicationConfig.Protocol}://${ApplicationConfig.Domain}:${ApplicationConfig.Port}/v1`
+     } else {
+           url = `${ApplicationConfig.Protocol}://${ApplicationConfig.Domain}/v1`
+     }  */
+    const adminClient = new Client()
+        .setEndpoint(url) // Your API Endpoint
+        .setProject('console');
+
+    return adminClient
+
+}

package/src/getSDKForService.ts

@@ -0,0 +1,71 @@
+import { getAppcondaClient } from "./getAppcondaClient";
+
+import { Account, BuilderService, DataSourceService, WaitlistService } from "./modules";
+import { AccountService } from "./modules/accounv1";
+import { TenantService } from "./modules/tenant/service";
+import { Configuration } from "./services/configuration";
+import { OrganizationService } from "./modules/organization/service";
+import { EmploidService } from "./modules/emploid/service";
+import { BpmService } from "./modules/bpm/service";
+export async function getSDKForService() {
+    const adminClient = await getAppcondaClient();
+
+    adminClient.addHeader('x-service-token', '');
+
+    const accounts = new AccountService(adminClient);
+    const tenants = new TenantService(adminClient);
+    const organization = new OrganizationService(adminClient);
+    const emploid = new EmploidService(adminClient);
+    const bpm = new BpmService(adminClient);
+    const datasource = new DataSourceService(adminClient);
+    const builder = new BuilderService(adminClient);
+
+/*     const databases = new Databases(adminClient);
+
+    const projects = new Projects(adminClient);
+
+    const currentUser = await accounts.get();
+
+    const users = new Users(adminClient);
+    const teams = new Teams(adminClient);
+
+   
+    const roles = new Roles(adminClient);
+    const permissions = new Permissions(adminClient);
+    const schemas = new Schemas(adminClient);
+
+    const community = new Community(adminClient);
+
+    const tenantSubscriptions = new TenantSubscription(adminClient);
+
+    const subscription = new Subscription(adminClient);
+    const pricing = new Pricing(adminClient); */
+    const waitlist = new WaitlistService(adminClient);
+    const configuration = new Configuration(adminClient);
+
+    return {
+        accounts,
+        tenants,
+        organization,
+        emploid,
+        bpm,
+        datasource,
+        builder,
+      /*   currentUser,
+        accounts,
+        databases,
+        projects,
+        users,
+        teams,
+        tenants,
+        roles,
+        permissions,
+        schemas,
+        community,
+        tenantSubscriptions,
+        subscription,
+        pricing, */
+        waitlist,
+        configuration
+    }
+}

package/src/id.ts

@@ -0,0 +1,47 @@
+/**
+ * Helper class to generate ID strings for resources.
+ */
+export class ID {
+    /**
+     * Generate an hex ID based on timestamp.
+     * Recreated from https://www.php.net/manual/en/function.uniqid.php
+     *
+     * @returns {string}
+     */
+    static #hexTimestamp(): string {
+        const now = new Date();
+        const sec = Math.floor(now.getTime() / 1000);
+        const msec = now.getMilliseconds();
+
+        // Convert to hexadecimal
+        const hexTimestamp = sec.toString(16) + msec.toString(16).padStart(5, '0');
+        return hexTimestamp;
+    }
+
+    /**
+     * Uses the provided ID as the ID for the resource.
+     *
+     * @param {string} id
+     * @returns {string}
+     */
+    public static custom(id: string): string {
+        return id
+    }
+
+    /**
+     * Have Appconda generate a unique ID for you.
+     * 
+     * @param {number} padding. Default is 7.
+     * @returns {string}
+     */
+    public static unique(padding: number = 7): string {
+        // Generate a unique ID with padding to have a longer ID
+        const baseId = ID.#hexTimestamp();
+        let randomPadding = '';
+        for (let i = 0; i < padding; i++) {
+            const randomHexDigit = Math.floor(Math.random() * 16).toString(16);
+            randomPadding += randomHexDigit;
+        }
+        return baseId + randomPadding;
+    }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export { getSDKForService } from './getSDKForService';
+
+

package/src/inputFile.ts

@@ -0,0 +1,23 @@
+import { File } from "node-fetch-native-with-agent";
+import { realpathSync, readFileSync } from "fs";
+import type { BinaryLike } from "crypto";
+
+export class InputFile {
+  static fromBuffer(
+    parts: Blob | BinaryLike,
+    name: string
+  ): File {
+    return new File([parts], name);
+  }
+
+  static fromPath(path: string, name: string): File {
+    const realPath = realpathSync(path);
+    const contents = readFileSync(realPath);
+    return this.fromBuffer(contents, name);
+  }
+
+  static fromPlainText(content: string, name: string): File {
+    const arrayBytes = new TextEncoder().encode(content);
+    return this.fromBuffer(arrayBytes, name);
+  }
+}

package/src/lib/errors.ts

@@ -0,0 +1,141 @@
+import { z } from "zod";
+
+class ResourceNotFoundError extends Error {
+  statusCode = 404;
+  resourceId: string | null;
+  resourceType: string;
+
+  constructor(resource: string, id: string | null) {
+    super(id ? `${resource} with ID ${id} not found` : `${resource} not found`);
+    this.name = "ResourceNotFoundError";
+    this.resourceType = resource;
+    this.resourceId = id;
+  }
+}
+
+class InvalidInputError extends Error {
+  statusCode = 400;
+  constructor(message: string) {
+    super(message);
+    this.name = "InvalidInputError";
+  }
+}
+
+class ValidationError extends Error {
+  statusCode = 400;
+  constructor(message: string) {
+    super(message);
+    this.name = "ValidationError";
+  }
+}
+
+class UnknownError extends Error {
+  statusCode = 500;
+  constructor(message: string) {
+    super(message);
+    this.name = "UnknownError";
+  }
+}
+
+class DatabaseError extends Error {
+  statusCode = 500;
+  constructor(message: string) {
+    super(message);
+    this.name = "DatabaseError";
+  }
+}
+
+class UniqueConstraintError extends Error {
+  statusCode = 409;
+  constructor(message: string) {
+    super(message);
+    this.name = "UniqueConstraintError";
+  }
+}
+
+class ForeignKeyConstraintError extends Error {
+  statusCode = 409;
+  constructor(message: string) {
+    super(message);
+    this.name = "ForeignKeyConstraintError";
+  }
+}
+
+class OperationNotAllowedError extends Error {
+  statusCode = 403;
+  constructor(message: string) {
+    super(message);
+    this.name = "OperationNotAllowedError";
+  }
+}
+
+class AuthenticationError extends Error {
+  statusCode = 401;
+  constructor(message: string) {
+    super(message);
+    this.name = "AuthenticationError";
+  }
+}
+
+class AuthorizationError extends Error {
+  statusCode = 403;
+  constructor(message: string) {
+    super(message);
+    this.name = "AuthorizationError";
+  }
+}
+
+interface NetworkError {
+  code: "network_error";
+  message: string;
+  status: number;
+  url: URL;
+  responseMessage?: string;
+  details?: Record<string, string | string[] | number | number[] | boolean | boolean[]>;
+}
+
+interface ForbiddenError {
+  code: "forbidden";
+  message: string;
+  status: number;
+  url: URL;
+  responseMessage?: string;
+  details?: Record<string, string | string[] | number | number[] | boolean | boolean[]>;
+}
+
+export const ZErrorHandler = z.function({
+  input: [z.any()],
+  output: z.void(),
+});
+
+export {
+  ResourceNotFoundError,
+  InvalidInputError,
+  ValidationError,
+  DatabaseError,
+  UniqueConstraintError,
+  UnknownError,
+  ForeignKeyConstraintError,
+  OperationNotAllowedError,
+  AuthenticationError,
+  AuthorizationError,
+};
+export type { NetworkError, ForbiddenError };
+
+export interface ApiErrorResponse {
+  code:
+    | "not_found"
+    | "gone"
+    | "bad_request"
+    | "internal_server_error"
+    | "unauthorized"
+    | "method_not_allowed"
+    | "not_authenticated"
+    | "forbidden"
+    | "network_error";
+  message: string;
+  status: number;
+  url: URL;
+  details?: Record<string, string | string[] | number | number[] | boolean | boolean[]>;
+  responseMessage?: string;
+}

package/src/lib/types.ts

@@ -0,0 +1,7 @@
+
+
+export interface ActionResult<T> {
+    data?: T;
+    serverError?: string;
+    validationError?: string;
+}