mirror of
https://github.com/eigent-ai/eigent.git
synced 2026-04-29 04:00:09 +00:00
795 lines
34 KiB
JavaScript
795 lines
34 KiB
JavaScript
"use strict";
|
|
var __defProp = Object.defineProperty;
|
|
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
|
|
var __getOwnPropNames = Object.getOwnPropertyNames;
|
|
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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
|
|
|
|
// src/lib/stack-app/apps/implementations/server-app-impl.ts
|
|
var server_app_impl_exports = {};
|
|
__export(server_app_impl_exports, {
|
|
_StackServerAppImplIncomplete: () => _StackServerAppImplIncomplete
|
|
});
|
|
module.exports = __toCommonJS(server_app_impl_exports);
|
|
var import_stack_shared = require("@stackframe/stack-shared");
|
|
var import_errors = require("@stackframe/stack-shared/dist/utils/errors");
|
|
var import_promises = require("@stackframe/stack-shared/dist/utils/promises");
|
|
var import_react = require("@stackframe/stack-shared/dist/utils/react");
|
|
var import_results = require("@stackframe/stack-shared/dist/utils/results");
|
|
var import_react2 = require("react");
|
|
var import_url = require("../../../../utils/url");
|
|
var import_api_keys = require("../../api-keys");
|
|
var import_contact_channels = require("../../contact-channels");
|
|
var import_teams = require("../../teams");
|
|
var import_users = require("../../users");
|
|
var import_client_app_impl = require("./client-app-impl");
|
|
var import_common = require("./common");
|
|
var import_common2 = require("./common");
|
|
var _StackServerAppImplIncomplete = class extends import_client_app_impl._StackClientAppImplIncomplete {
|
|
constructor(options) {
|
|
super("interface" in options ? {
|
|
interface: options.interface,
|
|
tokenStore: options.tokenStore,
|
|
urls: options.urls,
|
|
oauthScopesOnSignIn: options.oauthScopesOnSignIn
|
|
} : {
|
|
interface: new import_stack_shared.StackServerInterface({
|
|
getBaseUrl: () => (0, import_common.getBaseUrl)(options.baseUrl),
|
|
projectId: options.projectId ?? (0, import_common.getDefaultProjectId)(),
|
|
extraRequestHeaders: options.extraRequestHeaders ?? {},
|
|
clientVersion: import_common.clientVersion,
|
|
publishableClientKey: options.publishableClientKey ?? (0, import_common.getDefaultPublishableClientKey)(),
|
|
secretServerKey: options.secretServerKey ?? (0, import_common.getDefaultSecretServerKey)()
|
|
}),
|
|
baseUrl: options.baseUrl,
|
|
extraRequestHeaders: options.extraRequestHeaders,
|
|
projectId: options.projectId,
|
|
publishableClientKey: options.publishableClientKey,
|
|
tokenStore: options.tokenStore,
|
|
urls: options.urls,
|
|
oauthScopesOnSignIn: options.oauthScopesOnSignIn,
|
|
redirectMethod: options.redirectMethod
|
|
});
|
|
// TODO override the client user cache to use the server user cache, so we save some requests
|
|
this._currentServerUserCache = (0, import_common.createCacheBySession)(async (session) => {
|
|
if (session.isKnownToBeInvalid()) {
|
|
return null;
|
|
}
|
|
return await this._interface.getServerUserByToken(session);
|
|
});
|
|
this._serverUsersCache = (0, import_common.createCache)(async ([cursor, limit, orderBy, desc, query]) => {
|
|
return await this._interface.listServerUsers({ cursor, limit, orderBy, desc, query });
|
|
});
|
|
this._serverUserCache = (0, import_common.createCache)(async ([userId]) => {
|
|
const user = await this._interface.getServerUserById(userId);
|
|
return import_results.Result.or(user, null);
|
|
});
|
|
this._serverTeamsCache = (0, import_common.createCache)(async ([userId]) => {
|
|
return await this._interface.listServerTeams({ userId });
|
|
});
|
|
this._serverTeamUserPermissionsCache = (0, import_common.createCache)(async ([teamId, userId, recursive]) => {
|
|
return await this._interface.listServerTeamPermissions({ teamId, userId, recursive }, null);
|
|
});
|
|
this._serverUserProjectPermissionsCache = (0, import_common.createCache)(async ([userId, recursive]) => {
|
|
return await this._interface.listServerProjectPermissions({ userId, recursive }, null);
|
|
});
|
|
this._serverUserOAuthConnectionAccessTokensCache = (0, import_common.createCache)(
|
|
async ([userId, providerId, scope]) => {
|
|
try {
|
|
const result = await this._interface.createServerProviderAccessToken(userId, providerId, scope || "");
|
|
return { accessToken: result.access_token };
|
|
} catch (err) {
|
|
if (!(import_stack_shared.KnownErrors.OAuthConnectionDoesNotHaveRequiredScope.isInstance(err) || import_stack_shared.KnownErrors.OAuthConnectionNotConnectedToUser.isInstance(err))) {
|
|
throw err;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
);
|
|
this._serverUserOAuthConnectionCache = (0, import_common.createCache)(
|
|
async ([userId, providerId, scope, redirect]) => {
|
|
return await this._getUserOAuthConnectionCacheFn({
|
|
getUser: async () => import_results.Result.orThrow(await this._serverUserCache.getOrWait([userId], "write-only")),
|
|
getOrWaitOAuthToken: async () => import_results.Result.orThrow(await this._serverUserOAuthConnectionAccessTokensCache.getOrWait([userId, providerId, scope || ""], "write-only")),
|
|
useOAuthToken: () => (0, import_common2.useAsyncCache)(this._serverUserOAuthConnectionAccessTokensCache, [userId, providerId, scope || ""], "user.useConnectedAccount()"),
|
|
providerId,
|
|
scope,
|
|
redirect,
|
|
session: null
|
|
});
|
|
}
|
|
);
|
|
this._serverTeamMemberProfilesCache = (0, import_common.createCache)(
|
|
async ([teamId]) => {
|
|
return await this._interface.listServerTeamMemberProfiles({ teamId });
|
|
}
|
|
);
|
|
this._serverTeamInvitationsCache = (0, import_common.createCache)(
|
|
async ([teamId]) => {
|
|
return await this._interface.listServerTeamInvitations({ teamId });
|
|
}
|
|
);
|
|
this._serverUserTeamProfileCache = (0, import_common.createCache)(
|
|
async ([teamId, userId]) => {
|
|
return await this._interface.getServerTeamMemberProfile({ teamId, userId });
|
|
}
|
|
);
|
|
this._serverContactChannelsCache = (0, import_common.createCache)(
|
|
async ([userId]) => {
|
|
return await this._interface.listServerContactChannels(userId);
|
|
}
|
|
);
|
|
this._serverUserApiKeysCache = (0, import_common.createCache)(
|
|
async ([userId]) => {
|
|
const result = await this._interface.listProjectApiKeys({
|
|
user_id: userId
|
|
}, null, "server");
|
|
return result;
|
|
}
|
|
);
|
|
this._serverTeamApiKeysCache = (0, import_common.createCache)(
|
|
async ([teamId]) => {
|
|
const result = await this._interface.listProjectApiKeys({
|
|
team_id: teamId
|
|
}, null, "server");
|
|
return result;
|
|
}
|
|
);
|
|
this._serverCheckApiKeyCache = (0, import_common.createCache)(async ([type, apiKey]) => {
|
|
const result = await this._interface.checkProjectApiKey(
|
|
type,
|
|
apiKey,
|
|
null,
|
|
"server"
|
|
);
|
|
return result;
|
|
});
|
|
}
|
|
async _updateServerUser(userId, update) {
|
|
const result = await this._interface.updateServerUser(userId, (0, import_users.serverUserUpdateOptionsToCrud)(update));
|
|
await this._refreshUsers();
|
|
return result;
|
|
}
|
|
_serverEditableTeamProfileFromCrud(crud) {
|
|
const app = this;
|
|
return {
|
|
displayName: crud.display_name,
|
|
profileImageUrl: crud.profile_image_url,
|
|
async update(update) {
|
|
await app._interface.updateServerTeamMemberProfile({
|
|
teamId: crud.team_id,
|
|
userId: crud.user_id,
|
|
profile: {
|
|
display_name: update.displayName,
|
|
profile_image_url: update.profileImageUrl
|
|
}
|
|
});
|
|
await app._serverUserTeamProfileCache.refresh([crud.team_id, crud.user_id]);
|
|
}
|
|
};
|
|
}
|
|
_serverContactChannelFromCrud(userId, crud) {
|
|
const app = this;
|
|
return {
|
|
id: crud.id,
|
|
value: crud.value,
|
|
type: crud.type,
|
|
isVerified: crud.is_verified,
|
|
isPrimary: crud.is_primary,
|
|
usedForAuth: crud.used_for_auth,
|
|
async sendVerificationEmail(options) {
|
|
await app._interface.sendServerContactChannelVerificationEmail(userId, crud.id, options?.callbackUrl ?? (0, import_url.constructRedirectUrl)(app.urls.emailVerification, "callbackUrl"));
|
|
},
|
|
async update(data) {
|
|
await app._interface.updateServerContactChannel(userId, crud.id, (0, import_contact_channels.serverContactChannelUpdateOptionsToCrud)(data));
|
|
await Promise.all([
|
|
app._serverContactChannelsCache.refresh([userId]),
|
|
app._serverUserCache.refresh([userId])
|
|
]);
|
|
},
|
|
async delete() {
|
|
await app._interface.deleteServerContactChannel(userId, crud.id);
|
|
await Promise.all([
|
|
app._serverContactChannelsCache.refresh([userId]),
|
|
app._serverUserCache.refresh([userId])
|
|
]);
|
|
}
|
|
};
|
|
}
|
|
_serverApiKeyFromCrud(crud) {
|
|
return {
|
|
...this._baseApiKeyFromCrud(crud),
|
|
async revoke() {
|
|
await this.update({ revoked: true });
|
|
},
|
|
update: async (options) => {
|
|
await this._interface.updateProjectApiKey(
|
|
crud.type === "team" ? { team_id: crud.team_id } : { user_id: crud.user_id },
|
|
crud.id,
|
|
await (0, import_api_keys.apiKeyUpdateOptionsToCrud)(crud.type, options),
|
|
null,
|
|
"server"
|
|
);
|
|
if (crud.type === "team") {
|
|
await this._serverTeamApiKeysCache.refresh([crud.team_id]);
|
|
} else {
|
|
await this._serverUserApiKeysCache.refresh([crud.user_id]);
|
|
}
|
|
}
|
|
};
|
|
}
|
|
_serverUserFromCrud(crud) {
|
|
const app = this;
|
|
async function getConnectedAccount(id, options) {
|
|
const scopeString = options?.scopes?.join(" ");
|
|
return import_results.Result.orThrow(await app._serverUserOAuthConnectionCache.getOrWait([crud.id, id, scopeString || "", options?.or === "redirect"], "write-only"));
|
|
}
|
|
function useConnectedAccount(id, options) {
|
|
const scopeString = options?.scopes?.join(" ");
|
|
return (0, import_common2.useAsyncCache)(app._serverUserOAuthConnectionCache, [crud.id, id, scopeString || "", options?.or === "redirect"], "user.useConnectedAccount()");
|
|
}
|
|
return {
|
|
...super._createBaseUser(crud),
|
|
lastActiveAt: new Date(crud.last_active_at_millis),
|
|
serverMetadata: crud.server_metadata,
|
|
async setPrimaryEmail(email, options) {
|
|
await app._updateServerUser(crud.id, { primaryEmail: email, primaryEmailVerified: options?.verified });
|
|
},
|
|
async grantPermission(scopeOrPermissionId, permissionId) {
|
|
if (scopeOrPermissionId && typeof scopeOrPermissionId !== "string" && permissionId) {
|
|
const scope = scopeOrPermissionId;
|
|
await app._interface.grantServerTeamUserPermission(scope.id, crud.id, permissionId);
|
|
for (const recursive of [true, false]) {
|
|
await app._serverTeamUserPermissionsCache.refresh([scope.id, crud.id, recursive]);
|
|
}
|
|
} else {
|
|
const pId = scopeOrPermissionId;
|
|
await app._interface.grantServerProjectPermission(crud.id, pId);
|
|
for (const recursive of [true, false]) {
|
|
await app._serverUserProjectPermissionsCache.refresh([crud.id, recursive]);
|
|
}
|
|
}
|
|
},
|
|
async revokePermission(scopeOrPermissionId, permissionId) {
|
|
if (scopeOrPermissionId && typeof scopeOrPermissionId !== "string" && permissionId) {
|
|
const scope = scopeOrPermissionId;
|
|
await app._interface.revokeServerTeamUserPermission(scope.id, crud.id, permissionId);
|
|
for (const recursive of [true, false]) {
|
|
await app._serverTeamUserPermissionsCache.refresh([scope.id, crud.id, recursive]);
|
|
}
|
|
} else {
|
|
const pId = scopeOrPermissionId;
|
|
await app._interface.revokeServerProjectPermission(crud.id, pId);
|
|
for (const recursive of [true, false]) {
|
|
await app._serverUserProjectPermissionsCache.refresh([crud.id, recursive]);
|
|
}
|
|
}
|
|
},
|
|
async delete() {
|
|
const res = await app._interface.deleteServerUser(crud.id);
|
|
await app._refreshUsers();
|
|
return res;
|
|
},
|
|
async createSession(options) {
|
|
const tokens = await app._interface.createServerUserSession(crud.id, options.expiresInMillis ?? 1e3 * 60 * 60 * 24 * 365, options.isImpersonation ?? false);
|
|
return {
|
|
async getTokens() {
|
|
return tokens;
|
|
}
|
|
};
|
|
},
|
|
async getActiveSessions() {
|
|
const sessions = await app._interface.listServerSessions(crud.id);
|
|
return sessions.map((session) => app._clientSessionFromCrud(session));
|
|
},
|
|
async revokeSession(sessionId) {
|
|
await app._interface.deleteServerSession(sessionId);
|
|
},
|
|
async setDisplayName(displayName) {
|
|
return await this.update({ displayName });
|
|
},
|
|
async setClientMetadata(metadata) {
|
|
return await this.update({ clientMetadata: metadata });
|
|
},
|
|
async setClientReadOnlyMetadata(metadata) {
|
|
return await this.update({ clientReadOnlyMetadata: metadata });
|
|
},
|
|
async setServerMetadata(metadata) {
|
|
return await this.update({ serverMetadata: metadata });
|
|
},
|
|
async setSelectedTeam(team) {
|
|
return await this.update({ selectedTeamId: team?.id ?? null });
|
|
},
|
|
getConnectedAccount,
|
|
useConnectedAccount,
|
|
// THIS_LINE_PLATFORM react-like
|
|
selectedTeam: crud.selected_team ? app._serverTeamFromCrud(crud.selected_team) : null,
|
|
async getTeam(teamId) {
|
|
const teams = await this.listTeams();
|
|
return teams.find((t) => t.id === teamId) ?? null;
|
|
},
|
|
useTeam(teamId) {
|
|
const teams = this.useTeams();
|
|
return (0, import_react2.useMemo)(() => {
|
|
return teams.find((t) => t.id === teamId) ?? null;
|
|
}, [teams, teamId]);
|
|
},
|
|
async listTeams() {
|
|
const teams = import_results.Result.orThrow(await app._serverTeamsCache.getOrWait([crud.id], "write-only"));
|
|
return teams.map((t) => app._serverTeamFromCrud(t));
|
|
},
|
|
useTeams() {
|
|
const teams = (0, import_common2.useAsyncCache)(app._serverTeamsCache, [crud.id], "user.useTeams()");
|
|
return (0, import_react2.useMemo)(() => teams.map((t) => app._serverTeamFromCrud(t)), [teams]);
|
|
},
|
|
createTeam: async (data) => {
|
|
const team = await app._interface.createServerTeam((0, import_teams.serverTeamCreateOptionsToCrud)({
|
|
creatorUserId: crud.id,
|
|
...data
|
|
}));
|
|
await app._serverTeamsCache.refresh([void 0]);
|
|
await app._updateServerUser(crud.id, { selectedTeamId: team.id });
|
|
return app._serverTeamFromCrud(team);
|
|
},
|
|
leaveTeam: async (team) => {
|
|
await app._interface.leaveServerTeam({ teamId: team.id, userId: crud.id });
|
|
},
|
|
async listPermissions(scopeOrOptions, options) {
|
|
if (scopeOrOptions && "id" in scopeOrOptions) {
|
|
const scope = scopeOrOptions;
|
|
const recursive = options?.recursive ?? true;
|
|
const permissions = import_results.Result.orThrow(await app._serverTeamUserPermissionsCache.getOrWait([scope.id, crud.id, recursive], "write-only"));
|
|
return permissions.map((crud2) => app._serverPermissionFromCrud(crud2));
|
|
} else {
|
|
const opts = scopeOrOptions;
|
|
const recursive = opts?.recursive ?? true;
|
|
const permissions = import_results.Result.orThrow(await app._serverUserProjectPermissionsCache.getOrWait([crud.id, recursive], "write-only"));
|
|
return permissions.map((crud2) => app._serverPermissionFromCrud(crud2));
|
|
}
|
|
},
|
|
usePermissions(scopeOrOptions, options) {
|
|
if (scopeOrOptions && "id" in scopeOrOptions) {
|
|
const scope = scopeOrOptions;
|
|
const recursive = options?.recursive ?? true;
|
|
const permissions = (0, import_common2.useAsyncCache)(app._serverTeamUserPermissionsCache, [scope.id, crud.id, recursive], "user.usePermissions()");
|
|
return (0, import_react2.useMemo)(() => permissions.map((crud2) => app._serverPermissionFromCrud(crud2)), [permissions]);
|
|
} else {
|
|
const opts = scopeOrOptions;
|
|
const recursive = opts?.recursive ?? true;
|
|
const permissions = (0, import_common2.useAsyncCache)(app._serverUserProjectPermissionsCache, [crud.id, recursive], "user.usePermissions()");
|
|
return (0, import_react2.useMemo)(() => permissions.map((crud2) => app._serverPermissionFromCrud(crud2)), [permissions]);
|
|
}
|
|
},
|
|
async getPermission(scopeOrPermissionId, permissionId) {
|
|
if (scopeOrPermissionId && typeof scopeOrPermissionId !== "string") {
|
|
const scope = scopeOrPermissionId;
|
|
const permissions = await this.listPermissions(scope);
|
|
return permissions.find((p) => p.id === permissionId) ?? null;
|
|
} else {
|
|
const pid = scopeOrPermissionId;
|
|
const permissions = await this.listPermissions();
|
|
return permissions.find((p) => p.id === pid) ?? null;
|
|
}
|
|
},
|
|
usePermission(scopeOrPermissionId, permissionId) {
|
|
if (scopeOrPermissionId && typeof scopeOrPermissionId !== "string") {
|
|
const scope = scopeOrPermissionId;
|
|
const permissions = this.usePermissions(scope);
|
|
return (0, import_react2.useMemo)(() => permissions.find((p) => p.id === permissionId) ?? null, [permissions, permissionId]);
|
|
} else {
|
|
const pid = scopeOrPermissionId;
|
|
const permissions = this.usePermissions();
|
|
return (0, import_react2.useMemo)(() => permissions.find((p) => p.id === pid) ?? null, [permissions, pid]);
|
|
}
|
|
},
|
|
async hasPermission(scopeOrPermissionId, permissionId) {
|
|
if (scopeOrPermissionId && typeof scopeOrPermissionId !== "string") {
|
|
const scope = scopeOrPermissionId;
|
|
return await this.getPermission(scope, permissionId) !== null;
|
|
} else {
|
|
const pid = scopeOrPermissionId;
|
|
return await this.getPermission(pid) !== null;
|
|
}
|
|
},
|
|
async update(update) {
|
|
await app._updateServerUser(crud.id, update);
|
|
},
|
|
async sendVerificationEmail() {
|
|
return await app._checkFeatureSupport("sendVerificationEmail() on ServerUser", {});
|
|
},
|
|
async updatePassword(options) {
|
|
const result = await app._interface.updatePassword(options);
|
|
await app._serverUserCache.refresh([crud.id]);
|
|
return result;
|
|
},
|
|
async setPassword(options) {
|
|
const result = await this.update(options);
|
|
await app._serverUserCache.refresh([crud.id]);
|
|
return result;
|
|
},
|
|
async getTeamProfile(team) {
|
|
const result = import_results.Result.orThrow(await app._serverUserTeamProfileCache.getOrWait([team.id, crud.id], "write-only"));
|
|
return app._serverEditableTeamProfileFromCrud(result);
|
|
},
|
|
useTeamProfile(team) {
|
|
const result = (0, import_common2.useAsyncCache)(app._serverUserTeamProfileCache, [team.id, crud.id], "user.useTeamProfile()");
|
|
return (0, import_react2.useMemo)(() => app._serverEditableTeamProfileFromCrud(result), [result]);
|
|
},
|
|
async listContactChannels() {
|
|
const result = import_results.Result.orThrow(await app._serverContactChannelsCache.getOrWait([crud.id], "write-only"));
|
|
return result.map((data) => app._serverContactChannelFromCrud(crud.id, data));
|
|
},
|
|
useContactChannels() {
|
|
const result = (0, import_common2.useAsyncCache)(app._serverContactChannelsCache, [crud.id], "user.useContactChannels()");
|
|
return (0, import_react2.useMemo)(() => result.map((data) => app._serverContactChannelFromCrud(crud.id, data)), [result]);
|
|
},
|
|
createContactChannel: async (data) => {
|
|
const contactChannel = await app._interface.createServerContactChannel((0, import_contact_channels.serverContactChannelCreateOptionsToCrud)(crud.id, data));
|
|
await Promise.all([
|
|
app._serverContactChannelsCache.refresh([crud.id]),
|
|
app._serverUserCache.refresh([crud.id])
|
|
]);
|
|
return app._serverContactChannelFromCrud(crud.id, contactChannel);
|
|
},
|
|
useApiKeys() {
|
|
const result = (0, import_common2.useAsyncCache)(app._serverUserApiKeysCache, [crud.id], "user.useApiKeys()");
|
|
return result.map((apiKey) => app._serverApiKeyFromCrud(apiKey));
|
|
},
|
|
async listApiKeys() {
|
|
const result = import_results.Result.orThrow(await app._serverUserApiKeysCache.getOrWait([crud.id], "write-only"));
|
|
return result.map((apiKey) => app._serverApiKeyFromCrud(apiKey));
|
|
},
|
|
async createApiKey(options) {
|
|
const result = await app._interface.createProjectApiKey(
|
|
await (0, import_api_keys.apiKeyCreationOptionsToCrud)("user", crud.id, options),
|
|
null,
|
|
"server"
|
|
);
|
|
await app._serverUserApiKeysCache.refresh([crud.id]);
|
|
return app._serverApiKeyFromCrud(result);
|
|
}
|
|
};
|
|
}
|
|
_serverTeamUserFromCrud(crud) {
|
|
return {
|
|
...this._serverUserFromCrud(crud.user),
|
|
teamProfile: {
|
|
displayName: crud.display_name,
|
|
profileImageUrl: crud.profile_image_url
|
|
}
|
|
};
|
|
}
|
|
_serverTeamInvitationFromCrud(crud) {
|
|
return {
|
|
id: crud.id,
|
|
recipientEmail: crud.recipient_email,
|
|
expiresAt: new Date(crud.expires_at_millis),
|
|
revoke: async () => {
|
|
await this._interface.revokeServerTeamInvitation(crud.id, crud.team_id);
|
|
}
|
|
};
|
|
}
|
|
_currentUserFromCrud(crud, session) {
|
|
const app = this;
|
|
const currentUser = {
|
|
...this._serverUserFromCrud(crud),
|
|
...this._createAuth(session),
|
|
...this._isInternalProject() ? this._createInternalUserExtra(session) : {}
|
|
};
|
|
Object.freeze(currentUser);
|
|
return currentUser;
|
|
}
|
|
_serverTeamFromCrud(crud) {
|
|
const app = this;
|
|
return {
|
|
id: crud.id,
|
|
displayName: crud.display_name,
|
|
profileImageUrl: crud.profile_image_url,
|
|
createdAt: new Date(crud.created_at_millis),
|
|
clientMetadata: crud.client_metadata,
|
|
clientReadOnlyMetadata: crud.client_read_only_metadata,
|
|
serverMetadata: crud.server_metadata,
|
|
async update(update) {
|
|
await app._interface.updateServerTeam(crud.id, (0, import_teams.serverTeamUpdateOptionsToCrud)(update));
|
|
await app._serverTeamsCache.refresh([void 0]);
|
|
},
|
|
async delete() {
|
|
await app._interface.deleteServerTeam(crud.id);
|
|
await app._serverTeamsCache.refresh([void 0]);
|
|
},
|
|
async listUsers() {
|
|
const result = import_results.Result.orThrow(await app._serverTeamMemberProfilesCache.getOrWait([crud.id], "write-only"));
|
|
return result.map((u) => app._serverTeamUserFromCrud(u));
|
|
},
|
|
useUsers() {
|
|
const result = (0, import_common2.useAsyncCache)(app._serverTeamMemberProfilesCache, [crud.id], "team.useUsers()");
|
|
return (0, import_react2.useMemo)(() => result.map((u) => app._serverTeamUserFromCrud(u)), [result]);
|
|
},
|
|
async addUser(userId) {
|
|
await app._interface.addServerUserToTeam({
|
|
teamId: crud.id,
|
|
userId
|
|
});
|
|
await app._serverTeamMemberProfilesCache.refresh([crud.id]);
|
|
},
|
|
async removeUser(userId) {
|
|
await app._interface.removeServerUserFromTeam({
|
|
teamId: crud.id,
|
|
userId
|
|
});
|
|
await app._serverTeamMemberProfilesCache.refresh([crud.id]);
|
|
},
|
|
async inviteUser(options) {
|
|
await app._interface.sendServerTeamInvitation({
|
|
teamId: crud.id,
|
|
email: options.email,
|
|
callbackUrl: options.callbackUrl ?? (0, import_url.constructRedirectUrl)(app.urls.teamInvitation, "callbackUrl")
|
|
});
|
|
await app._serverTeamInvitationsCache.refresh([crud.id]);
|
|
},
|
|
async listInvitations() {
|
|
const result = import_results.Result.orThrow(await app._serverTeamInvitationsCache.getOrWait([crud.id], "write-only"));
|
|
return result.map((crud2) => app._serverTeamInvitationFromCrud(crud2));
|
|
},
|
|
useInvitations() {
|
|
const result = (0, import_common2.useAsyncCache)(app._serverTeamInvitationsCache, [crud.id], "team.useInvitations()");
|
|
return (0, import_react2.useMemo)(() => result.map((crud2) => app._serverTeamInvitationFromCrud(crud2)), [result]);
|
|
},
|
|
useApiKeys() {
|
|
const result = (0, import_common2.useAsyncCache)(app._serverTeamApiKeysCache, [crud.id], "team.useApiKeys()");
|
|
return result.map((apiKey) => app._serverApiKeyFromCrud(apiKey));
|
|
},
|
|
async listApiKeys() {
|
|
const result = import_results.Result.orThrow(await app._serverTeamApiKeysCache.getOrWait([crud.id], "write-only"));
|
|
return result.map((apiKey) => app._serverApiKeyFromCrud(apiKey));
|
|
},
|
|
async createApiKey(options) {
|
|
const result = await app._interface.createProjectApiKey(
|
|
await (0, import_api_keys.apiKeyCreationOptionsToCrud)("team", crud.id, options),
|
|
null,
|
|
"server"
|
|
);
|
|
await app._serverTeamApiKeysCache.refresh([crud.id]);
|
|
return app._serverApiKeyFromCrud(result);
|
|
}
|
|
};
|
|
}
|
|
async _getUserApiKey(options) {
|
|
const crud = import_results.Result.orThrow(await this._serverCheckApiKeyCache.getOrWait(["user", options.apiKey], "write-only"));
|
|
return crud ? this._serverApiKeyFromCrud(crud) : null;
|
|
}
|
|
async _getTeamApiKey(options) {
|
|
const crud = import_results.Result.orThrow(await this._serverCheckApiKeyCache.getOrWait(["team", options.apiKey], "write-only"));
|
|
return crud ? this._serverApiKeyFromCrud(crud) : null;
|
|
}
|
|
_useUserApiKey(options) {
|
|
const crud = (0, import_common2.useAsyncCache)(this._serverCheckApiKeyCache, ["user", options.apiKey], "useUserApiKey()");
|
|
return (0, import_react2.useMemo)(() => crud ? this._serverApiKeyFromCrud(crud) : null, [crud]);
|
|
}
|
|
_useTeamApiKey(options) {
|
|
const crud = (0, import_common2.useAsyncCache)(this._serverCheckApiKeyCache, ["team", options.apiKey], "useTeamApiKey()");
|
|
return (0, import_react2.useMemo)(() => crud ? this._serverApiKeyFromCrud(crud) : null, [crud]);
|
|
}
|
|
async _getUserByApiKey(apiKey) {
|
|
const apiKeyObject = await this._getUserApiKey({ apiKey });
|
|
if (apiKeyObject === null) {
|
|
return null;
|
|
}
|
|
return await this.getServerUserById(apiKeyObject.userId);
|
|
}
|
|
_useUserByApiKey(apiKey) {
|
|
const apiKeyObject = this._useUserApiKey({ apiKey });
|
|
if (apiKeyObject === null) {
|
|
return null;
|
|
}
|
|
return this.useUserById(apiKeyObject.userId);
|
|
}
|
|
async _getTeamByApiKey(apiKey) {
|
|
const apiKeyObject = await this._getTeamApiKey({ apiKey });
|
|
if (apiKeyObject === null) {
|
|
return null;
|
|
}
|
|
return await this.getTeam(apiKeyObject.teamId);
|
|
}
|
|
_useTeamByApiKey(apiKey) {
|
|
const apiKeyObject = this._useTeamApiKey({ apiKey });
|
|
if (apiKeyObject === null) {
|
|
return null;
|
|
}
|
|
return this.useTeam(apiKeyObject.teamId);
|
|
}
|
|
async createUser(options) {
|
|
const crud = await this._interface.createServerUser((0, import_users.serverUserCreateOptionsToCrud)(options));
|
|
await this._refreshUsers();
|
|
return this._serverUserFromCrud(crud);
|
|
}
|
|
async getUser(options) {
|
|
if (typeof options === "string") {
|
|
return await this.getServerUserById(options);
|
|
} else if (typeof options === "object" && "apiKey" in options) {
|
|
return await this._getUserByApiKey(options.apiKey);
|
|
} else {
|
|
this._ensurePersistentTokenStore(options?.tokenStore);
|
|
const session = await this._getSession(options?.tokenStore);
|
|
let crud = import_results.Result.orThrow(await this._currentServerUserCache.getOrWait([session], "write-only"));
|
|
if (crud?.is_anonymous && options?.or !== "anonymous" && options?.or !== "anonymous-if-exists") {
|
|
crud = null;
|
|
}
|
|
if (crud === null) {
|
|
switch (options?.or) {
|
|
case "redirect": {
|
|
await this.redirectToSignIn({ replace: true });
|
|
break;
|
|
}
|
|
case "throw": {
|
|
throw new Error("User is not signed in but getUser was called with { or: 'throw' }");
|
|
}
|
|
case "anonymous": {
|
|
const tokens = await this._signUpAnonymously();
|
|
return await this.getUser({ tokenStore: tokens, or: "anonymous-if-exists" }) ?? (0, import_errors.throwErr)("Something went wrong while signing up anonymously");
|
|
}
|
|
case void 0:
|
|
case "anonymous-if-exists":
|
|
case "return-null": {
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
return crud && this._currentUserFromCrud(crud, session);
|
|
}
|
|
}
|
|
async getServerUser() {
|
|
console.warn("stackServerApp.getServerUser is deprecated; use stackServerApp.getUser instead");
|
|
return await this.getUser();
|
|
}
|
|
async getServerUserById(userId) {
|
|
const crud = import_results.Result.orThrow(await this._serverUserCache.getOrWait([userId], "write-only"));
|
|
return crud && this._serverUserFromCrud(crud);
|
|
}
|
|
useUser(options) {
|
|
if (typeof options === "string") {
|
|
return this.useUserById(options);
|
|
} else if (typeof options === "object" && "apiKey" in options) {
|
|
return this._useUserByApiKey(options.apiKey);
|
|
} else {
|
|
this._ensurePersistentTokenStore(options?.tokenStore);
|
|
const session = this._useSession(options?.tokenStore);
|
|
let crud = (0, import_common2.useAsyncCache)(this._currentServerUserCache, [session], "useUser()");
|
|
if (crud?.is_anonymous && options?.or !== "anonymous" && options?.or !== "anonymous-if-exists") {
|
|
crud = null;
|
|
}
|
|
if (crud === null) {
|
|
switch (options?.or) {
|
|
case "redirect": {
|
|
(0, import_promises.runAsynchronously)(this.redirectToSignIn({ replace: true }));
|
|
(0, import_react.suspend)();
|
|
throw new import_errors.StackAssertionError("suspend should never return");
|
|
}
|
|
case "throw": {
|
|
throw new Error("User is not signed in but useUser was called with { or: 'throw' }");
|
|
}
|
|
case "anonymous": {
|
|
(0, import_promises.runAsynchronously)(async () => {
|
|
await this._signUpAnonymously();
|
|
if (typeof window !== "undefined") {
|
|
window.location.reload();
|
|
}
|
|
});
|
|
(0, import_react.suspend)();
|
|
throw new import_errors.StackAssertionError("suspend should never return");
|
|
}
|
|
case void 0:
|
|
case "anonymous-if-exists":
|
|
case "return-null": {
|
|
}
|
|
}
|
|
}
|
|
return (0, import_react2.useMemo)(() => {
|
|
return crud && this._currentUserFromCrud(crud, session);
|
|
}, [crud, session, options?.or]);
|
|
}
|
|
}
|
|
useUserById(userId) {
|
|
const crud = (0, import_common2.useAsyncCache)(this._serverUserCache, [userId], "useUserById()");
|
|
return (0, import_react2.useMemo)(() => {
|
|
return crud && this._serverUserFromCrud(crud);
|
|
}, [crud]);
|
|
}
|
|
async listUsers(options) {
|
|
const crud = import_results.Result.orThrow(await this._serverUsersCache.getOrWait([options?.cursor, options?.limit, options?.orderBy, options?.desc, options?.query], "write-only"));
|
|
const result = crud.items.map((j) => this._serverUserFromCrud(j));
|
|
result.nextCursor = crud.pagination?.next_cursor ?? null;
|
|
return result;
|
|
}
|
|
useUsers(options) {
|
|
const crud = (0, import_common2.useAsyncCache)(this._serverUsersCache, [options?.cursor, options?.limit, options?.orderBy, options?.desc, options?.query], "useServerUsers()");
|
|
const result = crud.items.map((j) => this._serverUserFromCrud(j));
|
|
result.nextCursor = crud.pagination?.next_cursor ?? null;
|
|
return result;
|
|
}
|
|
_serverPermissionFromCrud(crud) {
|
|
return {
|
|
id: crud.id
|
|
};
|
|
}
|
|
_serverTeamPermissionDefinitionFromCrud(crud) {
|
|
return {
|
|
id: crud.id,
|
|
description: crud.description,
|
|
containedPermissionIds: crud.contained_permission_ids
|
|
};
|
|
}
|
|
_serverProjectPermissionDefinitionFromCrud(crud) {
|
|
return {
|
|
id: crud.id,
|
|
description: crud.description,
|
|
containedPermissionIds: crud.contained_permission_ids
|
|
};
|
|
}
|
|
async listTeams() {
|
|
const teams = import_results.Result.orThrow(await this._serverTeamsCache.getOrWait([void 0], "write-only"));
|
|
return teams.map((t) => this._serverTeamFromCrud(t));
|
|
}
|
|
async createTeam(data) {
|
|
const team = await this._interface.createServerTeam((0, import_teams.serverTeamCreateOptionsToCrud)(data));
|
|
await this._serverTeamsCache.refresh([void 0]);
|
|
return this._serverTeamFromCrud(team);
|
|
}
|
|
useTeams() {
|
|
const teams = (0, import_common2.useAsyncCache)(this._serverTeamsCache, [void 0], "useServerTeams()");
|
|
return (0, import_react2.useMemo)(() => {
|
|
return teams.map((t) => this._serverTeamFromCrud(t));
|
|
}, [teams]);
|
|
}
|
|
async getTeam(options) {
|
|
if (typeof options === "object" && "apiKey" in options) {
|
|
return await this._getTeamByApiKey(options.apiKey);
|
|
} else {
|
|
const teamId = options;
|
|
const teams = await this.listTeams();
|
|
return teams.find((t) => t.id === teamId) ?? null;
|
|
}
|
|
}
|
|
useTeam(options) {
|
|
if (typeof options === "object" && "apiKey" in options) {
|
|
return this._useTeamByApiKey(options.apiKey);
|
|
} else {
|
|
const teamId = options;
|
|
const teams = this.useTeams();
|
|
return (0, import_react2.useMemo)(() => {
|
|
return teams.find((t) => t.id === teamId) ?? null;
|
|
}, [teams, teamId]);
|
|
}
|
|
}
|
|
async _refreshSession(session) {
|
|
await Promise.all([
|
|
super._refreshUser(session),
|
|
this._currentServerUserCache.refresh([session])
|
|
]);
|
|
}
|
|
async _refreshUsers() {
|
|
await Promise.all([
|
|
super._refreshUsers(),
|
|
this._serverUserCache.refreshWhere(() => true),
|
|
this._serverUsersCache.refreshWhere(() => true),
|
|
this._serverContactChannelsCache.refreshWhere(() => true)
|
|
]);
|
|
}
|
|
};
|
|
// Annotate the CommonJS export names for ESM import in node:
|
|
0 && (module.exports = {
|
|
_StackServerAppImplIncomplete
|
|
});
|
|
//# sourceMappingURL=server-app-impl.js.map
|