@appconda/sdk 1.0.194 → 1.0.410

package/src/modules/tenant/actions.ts

@@ -0,0 +1,173 @@
+'use server';
+import { z } from "zod";
+import { AppcondaException } from "../../client";
+import { getSDKForCurrentUser } from "../../getSDKForCurrentUser";
+import { getSDKForService } from "../../getSDKForService";
+import { CreateTenantSchema, CreateTenantUserSchema, GetTenantByIdSchema, ListTenantUsersSchema, ListUserTenantsSchema } from "./schema";
+import { TTenant, TTenantUser } from "./types";
+/*     
+const getTenantActionSchema = z.object({
+    tenantId: z.string()
+}); */
+/* 
+export const getTenantAction = async (parsedInput: z.infer<typeof getTenantActionSchema>) => {
+    try {
+        const { tenantId } = parsedInput;
+        const { tenants } = await getSDKForCurrentUser();
+        return await tenants.get(tenantId);
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+
+
+const listUserTenantsScheema = z.object({
+    userId: z.string()
+});
+
+export const listUserTenantsAction = async (parsedInput: z.infer<typeof listUserTenantsScheema>) => {
+    try {
+        const { userId } = parsedInput;
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        return await tenants.listUserTenants(userId);
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+
+const createTenantScheema = z.object({
+    id: z.string(),
+    name: z.string(),
+    slug: z.string()
+});
+
+export const createTenantAction = async (parsedInput: z.infer<typeof createTenantScheema>)=> {
+    try {
+        const { id, name, slug } = parsedInput;
+        const { tenants } = await getSDKForCurrentUser();
+        return await tenants.create({ $id: id, name: name, slug: slug, users: [] });
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}; */
+
+
+export const AdminGetAllTenantsIdsAndNames = async () => {
+    try {
+       
+        const { tenants } = await getSDKForService();
+        return await tenants.AdminGetAllTenantsIdsAndNames();
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+};
+
+
+export async function CreateTenant(parsedInput: z.infer<typeof CreateTenantSchema>): Promise<TTenant> {
+    try {
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        const app = await tenants.CreateTenant(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}
+
+export async function CreateTenantUser(parsedInput: z.infer<typeof CreateTenantUserSchema>): Promise<TTenantUser> {
+    try {
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        const app = await tenants.CreateTenantUser(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}
+
+export async function GetTenantById(parsedInput: z.infer<typeof GetTenantByIdSchema>): Promise<TTenant> {
+    try {
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        const app = await tenants.GetTenantById(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}
+
+export async function ListTenants(): Promise<TTenant[]> {
+    try {
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        const app = await tenants.ListTenants();
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}
+
+export async function ListTenantUsers(parsedInput: z.infer<typeof ListTenantUsersSchema>): Promise<TTenantUser[]> {
+    try {
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        const app = await tenants.ListTenantUsers(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}
+
+export async function ListUserTenants(parsedInput: z.infer<typeof ListUserTenantsSchema>): Promise<TTenant[]> {
+    try {
+        const { tenants } = await getSDKForService();
+        //@ts-ignore
+        const app = await tenants.ListUserTenants(parsedInput);
+        return app;
+    } catch (error) {
+        if (error instanceof AppcondaException) {
+            throw new Error(error.message);
+        }
+
+        throw error;
+    }
+}

package/src/modules/tenant/index.ts

@@ -0,0 +1,3 @@
+export * from "./service";
+export * from "./types";
+export * from "./actions";

package/src/modules/tenant/schema.ts

@@ -0,0 +1,32 @@
+import z from "zod";
+
+export const CreateTenantSchema = z.object({
+    id: z.string(),
+    name: z.string(),
+    slug: z.string()
+});
+
+export enum TenantUserType {
+    OWNER,
+    ADMIN,
+    MEMBER,
+}
+
+export const CreateTenantUserSchema = z.object({
+    tenantId: z.string(),
+    userId: z.string(),
+    type: z.nativeEnum(TenantUserType)
+});
+
+export const GetTenantByIdSchema = z.object({
+    tenantId: z.string()
+});
+
+export const ListTenantUsersSchema = z.object({
+    queries: z.array(z.string()),
+    search: z.string()
+});
+
+export const ListUserTenantsSchema = z.object({
+    userId: z.string()
+});

package/src/modules/tenant/service.ts

@@ -0,0 +1,43 @@
+
+import z from "zod";
+import { ServiceClient } from "../../service-client";
+import { TTenant, TTenantUser } from "./types";
+import { CreateTenantSchema, CreateTenantUserSchema, GetTenantByIdSchema, ListTenantUsersSchema, ListUserTenantsSchema } from "./schema";
+
+
+
+export class TenantService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.tenant';
+    }
+
+    public async AdminGetAllTenantsIdsAndNames(): Promise<TTenant> {
+        return await this.actionCall('AdminGetAllTenantsIdsAndNames', {});
+    }
+
+    public async CreateTenant(payload: z.infer<typeof CreateTenantSchema>): Promise<TTenant> {
+        return await this.actionCall('CreateTenant', payload);
+    }
+
+    public async CreateTenantUser(payload: z.infer<typeof CreateTenantUserSchema>): Promise<TTenantUser> {
+        return await this.actionCall('CreateTenantUser', payload);
+    }
+
+
+    public async GetTenantById(payload: z.infer<typeof GetTenantByIdSchema>): Promise<TTenant> {
+        return await this.actionCall('GetTenantById', payload);
+    }
+
+    public async ListTenants(): Promise<TTenant[]> {
+        return await this.actionCall('ListTenants', {});
+    }
+
+    public async ListTenantUsers(payload: z.infer<typeof ListTenantUsersSchema>): Promise<TTenantUser[]> {
+        return await this.actionCall('ListTenantUsers', payload);
+    }
+
+    public async ListUserTenants(payload: z.infer<typeof ListUserTenantsSchema>): Promise<TTenant[]> {
+        return await this.actionCall('ListUserTenants', payload);
+    }
+
+}

package/src/modules/tenant/tenant.ts

@@ -0,0 +1,193 @@
+import { AppcondaException, Client, Models, Payload } from "../../client";
+import { ServiceClient } from "../../service-client";
+
+export type TenantSimple = {
+    id: string;
+    name: string;
+    slug: string;
+    icon: string | null;
+    deactivatedReason: string | null;
+    types: any[];
+    active: boolean;
+};
+
+export class _TenantService extends ServiceClient {
+
+    public getServiceName(): string {
+        return 'com.appconda.service.tenant';
+    }
+
+
+    async get(tenantId: string): Promise<Models.Tenant> {
+        if (typeof tenantId === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "tenantId"');
+        }
+        const apiPath = '/tenants/{tenantId}'.replace('{tenantId}', tenantId);
+        const payload: Payload = {};
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+            'content-type': 'application/json',
+        }
+
+        return await this.client.call(
+            'get',
+            uri,
+            apiHeaders,
+            payload,
+        );
+    }
+    /**
+     * Create account
+     *
+     * Use this endpoint to allow a new user to register a new account in your project. After the user registration completes successfully, you can use the [/account/verfication](https://appconda.io/docs/references/cloud/client-web/account#createVerification) route to start verifying the user email address. To allow the new user to login to their new account, you need to create a new [account session](https://appconda.io/docs/references/cloud/client-web/account#createEmailSession).
+     *
+     * @param {string} tenantId
+     * @param {string} name
+     * @param {string} slug
+     * @throws {AppcondaException}
+     * @returns {Promise<Models.User<Preferences>>}
+     */
+    async create({ $id, name, slug }: Models.Tenant): Promise<Models.Tenant> {
+        if (typeof $id === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "tenantId"');
+        }
+        if (typeof name === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "name"');
+        }
+        if (typeof slug === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "slug"');
+        }
+        const apiPath = '/tenants';
+
+        const payload: Payload = {};
+        if (typeof $id !== 'undefined') {
+            payload['tenantId'] = $id;
+        }
+        if (typeof name !== 'undefined') {
+            payload['name'] = name;
+        }
+        if (typeof slug !== 'undefined') {
+            payload['slug'] = slug;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+            'content-type': 'application/json',
+        }
+
+        return await this.client.call(
+            'post',
+            uri,
+            apiHeaders,
+            payload,
+        );
+    }
+
+    async list(queries?: string[], search?: string): Promise<Models.TenantList> {
+        const apiPath = '/tenants';
+        const payload: Payload = {};
+        if (typeof queries !== 'undefined') {
+            payload['queries'] = queries;
+        }
+        if (typeof search !== 'undefined') {
+            payload['search'] = search;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+            'content-type': 'application/json',
+        }
+
+        return await this.client.call(
+            'get',
+            uri,
+            apiHeaders,
+            payload,
+        );
+    }
+
+    async listUserTenants(userId: string, queries?: string[], search?: string): Promise<Models.TenantUserList> {
+        const apiPath = `/tenants/${userId}/tenants`;
+        const payload: Payload = {};
+        if (typeof queries !== 'undefined') {
+            payload['queries'] = queries;
+        }
+        if (typeof search !== 'undefined') {
+            payload['search'] = search;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+            'content-type': 'application/json',
+        }
+
+        return await this.client.call(
+            'get',
+            uri,
+            apiHeaders,
+            payload,
+        );
+    }
+
+    async listTenantUsers(tenantId: string, queries?: string[], search?: string): Promise<Models.TenantUserList> {
+        const apiPath = `/tenants/${tenantId}/users`;
+        const payload: Payload = {};
+        if (typeof queries !== 'undefined') {
+            payload['queries'] = queries;
+        }
+        if (typeof search !== 'undefined') {
+            payload['search'] = search;
+        }
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+            'content-type': 'application/json',
+        }
+
+        return await this.client.call(
+            'get',
+            uri,
+            apiHeaders,
+            payload,
+        );
+    }
+
+    async createTenantUser({ tenantId, userId }: Models.TenantUser): Promise<Models.TenantUser> {
+
+        if (typeof tenantId === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "tenantId"');
+        }
+        if (typeof userId === 'undefined') {
+            throw new AppcondaException('Missing required parameter: "userId"');
+        }
+        const apiPath = `/tenants/${tenantId}/users`;
+
+        const payload: Payload = {};
+
+        if (typeof userId !== 'undefined') {
+            payload['userId'] = userId;
+        }
+
+        const uri = new URL(this.client.config.endpoint + apiPath);
+
+        const apiHeaders: { [header: string]: string } = {
+            'content-type': 'application/json',
+        }
+
+        return await this.client.call(
+            'post',
+            uri,
+            apiHeaders,
+            payload,
+        );
+    }
+
+    public async adminGetAllTenantsIdsAndNames(): Promise<TenantSimple[]> {
+        const payload: Payload = {};
+
+        return await this.actionCall('AdminGetAllTenantsIdsAndNames', payload);
+    }
+
+}

package/src/modules/tenant/types.ts

@@ -0,0 +1,22 @@
+import { TenantUserType } from "../../enums/tenants/TenantUserType"
+
+export type TTenant = {
+    id: string
+    createdAt: Date
+    updatedAt: Date
+    slug: string
+    name: string
+    icon: string | null
+    subscriptionId: string | null
+    active: boolean
+    deactivatedReason: string | null
+} 
+
+export type TTenantUser = {
+    id: string
+    createdAt: Date
+    updatedAt: Date
+    tenantId: string
+    userId: string
+    type: TenantUserType
+}

package/src/modules/waitlist/action.ts

@@ -0,0 +1,93 @@
+'use server';
+
+
+import { actionClient } from '../../actions/actionClient';
+import { getSDKForCurrentUser } from '../../getSDKForCurrentUser';
+import { getSDKForService } from '../../getSDKForService';
+import { CreateWaitlistOffboardedSignupSchema, CreateWaitlistSchema, CreateWaitlistSignupSchema, ListWaitlistOffboardedSignupsSchema, ListWaitlistSignupsSchema } from "./schema";
+import { Waitlist, WaitlistSignup } from './types';
+
+
+
+
+export const ListWaitlistSignups = actionClient
+    .schema(ListWaitlistSignupsSchema)
+    .action(async ({ parsedInput }): Promise<WaitlistSignup[]> => {
+        try {
+            const { waitlistId } = parsedInput;
+            const { waitlist } = await getSDKForService();
+            return await waitlist.ListWiatlistSignups(waitlistId); // typo: Wiatlist mi?
+        } catch (error) {
+            console.error('Error in ListWaitlistSignups:', error);
+            throw new Error('Failed to fetch ListWaitlistSignups');
+        }
+    });
+
+export const ListWaitlists = actionClient
+    .action(async (): Promise<Waitlist[]> => {
+        try {
+            const { waitlist } = await getSDKForService();
+            return await waitlist.ListWaitlists();
+        } catch (error) {
+            console.error('Error in ListWaitlists:', error);
+            throw new Error('Failed to fetch ListWaitlists');
+        }
+    });
+
+
+export const CreateWaitlist = actionClient
+    .schema(CreateWaitlistSchema)
+    .action(async ({ parsedInput }): Promise<Waitlist> => {
+        try {
+
+            const { waitlist } = await getSDKForCurrentUser();
+            return await waitlist.CreateWaitlist(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListWaitlists:', error);
+            throw new Error('Failed to fetch ListWaitlists');
+        }
+    });
+
+
+export const CreateWaitlistSignup = actionClient
+    .schema(CreateWaitlistSignupSchema)
+    .action(async ({ parsedInput }): Promise<WaitlistSignup> => {
+        try {
+
+            const { waitlist } = await getSDKForService();
+            return await waitlist.CreateWaitlistSignup(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListWaitlists:', error);
+            throw new Error('Failed to fetch ListWaitlists');
+        }
+    });
+
+    export const CreateWaitlistOffboardedSignup = actionClient
+    .schema(CreateWaitlistOffboardedSignupSchema)
+    .action(async ({ parsedInput }): Promise<WaitlistSignup> => {
+        try {
+
+            const { waitlist } = await getSDKForService();
+            return await waitlist.CreateWaitlistOffboardedSignup(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListWaitlists:', error);
+            throw new Error('Failed to fetch ListWaitlists');
+        }
+    });
+
+    export const ListWaitlistOffboardedSignups = actionClient
+    .schema(ListWaitlistOffboardedSignupsSchema)
+    .action(async ({ parsedInput }): Promise<WaitlistSignup> => {
+        try {
+
+            const { waitlist } = await getSDKForService();
+            return await waitlist.ListWaitlistOffboardedSignups(parsedInput);
+
+        } catch (error) {
+            console.error('Error in ListWaitlists:', error);
+            throw new Error('Failed to fetch ListWaitlists');
+        }
+    });

package/src/modules/waitlist/index.ts

@@ -0,0 +1,4 @@
+export * from './action';
+export * from './schema';
+export * from './service';
+export * from './types';

package/src/modules/waitlist/schema.ts

@@ -0,0 +1,24 @@
+import { z } from "zod";
+
+
+export const ListWaitlistSignupsSchema = z.object({
+    waitlistId: z.string()
+});
+
+export const ListWaitlistOffboardedSignupsSchema = z.object({
+    waitlistId: z.string()
+});
+
+export const CreateWaitlistSchema = z.object({
+    name: z.string()
+});
+
+export const CreateWaitlistSignupSchema = z.object({
+    waitlistId: z.string(),
+    email: z.string()
+});
+
+
+export const CreateWaitlistOffboardedSignupSchema = z.object({
+    waitlistSignupId: z.string(),
+});

package/src/modules/waitlist/service.ts

@@ -0,0 +1,41 @@
+
+import z from "zod";
+import { Payload } from "../../client";
+import { ServiceClient } from "../../service-client";
+import { Waitlist, WaitlistOffboardedSignup, WaitlistSignup } from "./types";
+import { CreateWaitlistOffboardedSignupSchema, CreateWaitlistSchema, CreateWaitlistSignupSchema, ListWaitlistOffboardedSignupsSchema } from "./schema";
+
+export class WaitlistService extends ServiceClient {
+    protected getServiceName(): string {
+        return 'com.appconda.service.waitlist';
+    }
+
+    public async ListWiatlistSignups(waitlistId: string): Promise<any[]> {
+        const payload: Payload = {};
+        payload['waitlistId'] = waitlistId;
+        return await this.actionCall('ListWiatlistSignups', payload);
+    }
+
+    public async ListWaitlists(): Promise<any[]> {
+        const payload: Payload = {};
+        return await this.actionCall('ListWaitlists', payload);
+    }
+
+    public async CreateWaitlist(payload: z.infer<typeof CreateWaitlistSchema>): Promise<Waitlist> {
+        return await this.actionCall('CreateWaitlist', payload);
+    }
+
+    public async CreateWaitlistSignup(payload: z.infer<typeof CreateWaitlistSignupSchema>): Promise<WaitlistSignup> {
+        return await this.actionCall('CreateWaitlistSignup', payload);
+    }
+
+    public async CreateWaitlistOffboardedSignup(payload: z.infer<typeof CreateWaitlistOffboardedSignupSchema>): Promise<WaitlistSignup> {
+        return await this.actionCall('CreateWaitlistOffboardedSignup', payload);
+    }
+
+    public async ListWaitlistOffboardedSignups(payload: z.infer<typeof ListWaitlistOffboardedSignupsSchema>): Promise<WaitlistOffboardedSignup> {
+        return await this.actionCall('ListOffboardedSignups', payload);
+    }
+    
+
+}

package/src/modules/waitlist/types.ts

@@ -0,0 +1,18 @@
+
+export interface WaitlistSignup {
+    email: string;
+}
+
+export interface Waitlist {
+    name: string;
+}
+
+export interface WaitlistSignup {
+    id: string;
+    email: string;
+}
+
+export interface WaitlistOffboardedSignup {
+    id: string;
+    email: string;
+}