agentlang 0.4.8 → 0.4.9

package/src/runtime/modules/auth.ts

@@ -380,16 +380,44 @@ entity Session {
   await Auth.getUserInfoByEmail(getUserByEmail.email)
 }
 
+@public workflow getUsersDetail {
+  {User? {},
+   UserRole {Role? {}},
+   @into {
+    id User.id,
+    email User.email,
+    firstName User.firstName,
+    lastName User.lastName,
+    lastLoginTime User.lastLoginTime,
+    status User.status,
+    role Role.name}
+  }
+}
+
 @public workflow inviteUser {
-  await Auth.inviteUser(inviteUser.email, inviteUser.firstName, inviteUser.lastName, inviteUser.userData)
+  await Auth.inviteUser(inviteUser.email, inviteUser.firstName, inviteUser.lastName, inviteUser.userData, inviteUser.role)
 }
 
 @public workflow inviteUsers {
   for u in inviteUsers.users {
-    {inviteUser {email u.email, firstName u.firstName, lastName u.lastName, userData u.userData}}
+    {inviteUser {email u.email, firstName u.firstName, lastName u.lastName, userData u.userData, role u.role}}
   }
 }
 
+record ResendInvitationResult {
+  message String
+}
+
+@public workflow resendInvitation {
+  {User {email? resendInvitation.email}} @as [u]
+  if (u and u.status == "Invited") {
+    await Auth.resendInvitationUser(u.email)
+  } else if (u) {
+    {ResendInvitationResult {message "User is not invited"}}
+  } else {
+    {ResendInvitationResult {message "User not found"}}
+  }
+}
 
 @public workflow acceptInvitation {
   await Auth.acceptInvitationUser(acceptInvitation.email, acceptInvitation.tempPassword, acceptInvitation.newPassword)
@@ -1336,6 +1364,7 @@ export async function inviteUser(
   firstName: string,
   lastName: string,
   userData: Map<string, any> | undefined,
+  role: string | undefined,
   env: Environment
 ): Promise<object> {
   const needCommit = env ? false : true;
@@ -1343,9 +1372,17 @@ export async function inviteUser(
   const f = async () => {
     try {
       let invitationInfo: any;
-      await fetchAuthImpl().inviteUser(email, firstName, lastName, userData, env, (info: any) => {
-        invitationInfo = info;
-      });
+      await fetchAuthImpl().inviteUser(
+        email,
+        firstName,
+        lastName,
+        userData,
+        role,
+        env,
+        (info: any) => {
+          invitationInfo = info;
+        }
+      );
 
       return {
         email: invitationInfo.email,
@@ -1366,6 +1403,28 @@ export async function inviteUser(
   }
 }
 
+export async function resendInvitationUser(email: string, env: Environment): Promise<object> {
+  const needCommit = env ? false : true;
+  env = env ? env : new Environment();
+  const f = async () => {
+    try {
+      await fetchAuthImpl().resendInvitation(email, env);
+      return {
+        email: email,
+        message: 'Invitation resent successfully',
+      };
+    } catch (err: any) {
+      logger.error(`Invitation resend failed: ${err.message}`);
+      throw err;
+    }
+  };
+  if (needCommit) {
+    return await env.callInTransaction(f);
+  } else {
+    return await f();
+  }
+}
+
 export async function acceptInvitationUser(
   email: string,
   tempPassword: string,
@@ -1413,6 +1472,7 @@ export function requireAuth(moduleName: string, eventName: string): boolean {
         eventName == 'confirmForgotPassword' ||
         eventName == 'refreshToken' ||
         eventName == 'acceptInvitation' ||
+        eventName == 'resendInvitation' ||
         eventName == 'callback');
     return !f;
   } else {

package/src/runtime/modules/core.ts

@@ -1,5 +1,6 @@
 import { default as ai } from './ai.js';
 import { default as auth } from './auth.js';
+import { default as files } from './files.js';
 import { DefaultModuleName, DefaultModules, escapeSpecialChars } from '../util.js';
 import { Instance, isInstanceOfType, makeInstance, newInstanceAttributes } from '../module.js';
 import {
@@ -87,7 +88,7 @@ export const CoreModules: string[] = [];
 export function registerCoreModules() {
   DefaultModules.add(DefaultModuleName);
   CoreModules.push(CoreModuleDefinition);
-  [auth, ai].forEach((mdef: string) => {
+  [auth, ai, files].forEach((mdef: string) => {
     CoreModules.push(mdef);
     DefaultModules.add(mdef);
   });

package/src/runtime/modules/files.ts

@@ -0,0 +1,183 @@
+import { Result, Environment, evaluate } from '../interpreter.js';
+import { makeCoreModuleName } from '../util.js';
+import { Instance, makeInstance, objectAsInstanceAttributes } from '../module.js';
+import crypto from 'crypto';
+import { ActiveSessionInfo } from '../auth/defs.js';
+
+export const CoreFilesModuleName = makeCoreModuleName('files');
+
+export default `module ${CoreFilesModuleName}
+
+entity File {
+    id String @id,
+    filename String @unique @indexed,
+    originalName String @optional,
+    mimetype String @default("application/octet-stream"),
+    size Int @optional,
+    uploadedBy String @optional,
+    uploadedAt DateTime @default(now()),
+    path String @optional,
+    @rbac [(allow: [create, read, update, delete], where: auth.user = this.uploadedBy)]
+}
+
+@public workflow CreateFile {
+  {File {id CreateFile.id,
+         filename CreateFile.filename,
+         originalName CreateFile.originalName,
+         mimetype CreateFile.mimetype,
+         size CreateFile.size,
+         uploadedBy CreateFile.uploadedBy,
+         uploadedAt CreateFile.uploadedAt,
+         path CreateFile.path},
+  @upsert}
+}
+
+@public workflow FindFile {
+  {File {id? FindFile.id}} @as [file];
+  file
+}
+
+@public workflow FindFileByFilename {
+  {File {filename? FindFileByFilename.filename}} @as [file];
+  file
+}
+
+@public workflow ListFiles {
+  {File? {}}
+}
+
+@public workflow ListUserFiles {
+  {File {uploadedBy? ListUserFiles.userId}}
+}
+
+@public workflow DeleteFile {
+  delete {File {id? DeleteFile.id}}
+}
+
+@public workflow DeleteFileByFilename {
+  delete {File {filename? DeleteFileByFilename.filename}}
+}
+
+@public workflow UpdateFile {
+  {File {id? UpdateFile.id,
+         originalName UpdateFile.originalName,
+         mimetype UpdateFile.mimetype,
+         size UpdateFile.size}}
+}
+`;
+
+export async function createFileRecord(
+  fileInfo: {
+    filename: string;
+    originalName: string;
+    mimetype: string;
+    size: number;
+    path: string;
+    uploadedBy?: string;
+  },
+  sessionInfo?: ActiveSessionInfo,
+  callback?: (result: Result) => void,
+  env?: Environment
+): Promise<Result> {
+  let inst: Instance = makeInstance(
+    CoreFilesModuleName,
+    'CreateFile',
+    objectAsInstanceAttributes({
+      id: crypto.randomUUID(),
+      filename: fileInfo.filename,
+      originalName: fileInfo.originalName,
+      mimetype: fileInfo.mimetype,
+      size: fileInfo.size,
+      path: fileInfo.path,
+      uploadedBy: fileInfo.uploadedBy || '',
+      uploadedAt: new Date().toISOString(),
+    })
+  );
+
+  if (sessionInfo) {
+    inst = inst.setAuthContext(sessionInfo);
+  }
+
+  return await evaluate(inst, callback, env);
+}
+
+export async function findFileByFilename(
+  filename: string,
+  sessionInfo?: ActiveSessionInfo,
+  callback?: (result: Result) => void,
+  env?: Environment
+): Promise<Result> {
+  let inst: Instance = makeInstance(
+    CoreFilesModuleName,
+    'FindFileByFilename',
+    objectAsInstanceAttributes({
+      filename: filename,
+    })
+  );
+
+  if (sessionInfo) {
+    inst = inst.setAuthContext(sessionInfo);
+  }
+
+  return await evaluate(inst, callback, env);
+}
+
+export async function deleteFileRecord(
+  filename: string,
+  sessionInfo?: ActiveSessionInfo,
+  callback?: (result: Result) => void,
+  env?: Environment
+): Promise<Result> {
+  let inst: Instance = makeInstance(
+    CoreFilesModuleName,
+    'DeleteFileByFilename',
+    objectAsInstanceAttributes({
+      filename: filename,
+    })
+  );
+
+  if (sessionInfo) {
+    inst = inst.setAuthContext(sessionInfo);
+  }
+
+  return await evaluate(inst, callback, env);
+}
+
+export async function listAllFiles(
+  sessionInfo?: ActiveSessionInfo,
+  callback?: (result: Result) => void,
+  env?: Environment
+): Promise<Result> {
+  let inst: Instance = makeInstance(
+    CoreFilesModuleName,
+    'ListFiles',
+    objectAsInstanceAttributes({})
+  );
+
+  if (sessionInfo) {
+    inst = inst.setAuthContext(sessionInfo);
+  }
+
+  return await evaluate(inst, callback, env);
+}
+
+export async function listUserFiles(
+  userId: string,
+  sessionInfo?: ActiveSessionInfo,
+  callback?: (result: Result) => void,
+  env?: Environment
+): Promise<Result> {
+  let inst: Instance = makeInstance(
+    CoreFilesModuleName,
+    'ListUserFiles',
+    objectAsInstanceAttributes({
+      userId: userId,
+    })
+  );
+
+  if (sessionInfo) {
+    inst = inst.setAuthContext(sessionInfo);
+  }
+
+  return await evaluate(inst, callback, env);
+}

package/src/runtime/state.ts

@@ -6,10 +6,12 @@ export const ConfigSchema = z.object({
     .object({
       port: z.number(),
       host: z.string().optional(),
+      httpFileHandling: z.boolean().default(false),
     })
     .default({
       port: 8080,
       host: 'localhost',
+      httpFileHandling: false,
     }),
   store: z
     .discriminatedUnion('type', [

package/src/runtime/util.ts

@@ -222,6 +222,7 @@ export function arrayEquals(a: Array<any>, b: Array<any>) {
 
 export const DefaultModuleName = 'agentlang';
 export const DefaultModules = new Set();
+export const DefaultFileHandlingDirectory = 'fs';
 
 export function makeCoreModuleName(n: string): string {
   return DefaultModuleName + '.' + n;