firstly 0.0.8 → 0.0.10

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # firstly
 
+## 0.0.10
+
+### Patch Changes
+
+- [#51](https://github.com/jycouet/firstly/pull/51)
+  [`803023a`](https://github.com/jycouet/firstly/commit/803023a6257c0bfb9396bc0a7bd454bd1281e26c)
+  Thanks [@jycouet](https://github.com/jycouet)! - prepare 0.0.10
+
+## 0.0.9
+
+### Patch Changes
+
+- [#43](https://github.com/jycouet/firstly/pull/43)
+  [`46cfc39`](https://github.com/jycouet/firstly/commit/46cfc39090fc448a22c5ca95e45507a31ab8e2e0)
+  Thanks [@jycouet](https://github.com/jycouet)! - better enum filter, grid action left/right, bump
+  deps, opti session check, action after createOptionWhenNoResult
+
 ## 0.0.8
 
 ### Patch Changes

package/esm/BaseEnum.d.ts

@@ -1,4 +1,3 @@
-import { type IdFilter } from 'remult';
 import type { FindOptionsBase, Repository } from 'remult';
 export type FF_Icon = {
     data?: string | string[];
@@ -15,30 +14,20 @@ export type BaseItem = BaseEnumOptions & {
     sub?: {
         captionPre?: string;
         repo?: Repository<any>;
-        item?: any;
+        items?: any[];
     };
 };
 export type BaseEnumOptions<Entity = any> = {
     caption?: string;
     icon?: FF_Icon;
-    where?: IdFilter<Entity> | FindOptionsBase<Entity>['where'];
+    where?: FindOptionsBase<Entity>['where'];
     class?: string;
 };
 export declare class BaseEnum<Entity = any> {
     id: string;
     caption?: string;
     icon?: FF_Icon;
-    where?: IdFilter<Entity> | FindOptionsBase<Entity>['where'];
+    where?: FindOptionsBase<Entity>['where'];
     class?: string;
     constructor(_id: string | number, options?: BaseEnumOptions<Entity>);
-    getWhere: () => this | Entity[] | {
-        $ne?: Entity | Entity[] | undefined;
-        '!='?: Entity | Entity[] | undefined;
-        $in?: Entity[] | undefined;
-        $nin?: Entity[] | undefined;
-    } | {
-        $id: import("remult").ValueFilter<Entity extends {
-            id?: number | undefined;
-        } ? number : string>;
-    } | import("remult").EntityFilter<Entity> | NonNullable<Entity>;
 }

package/esm/BaseEnum.js

@@ -1,4 +1,3 @@
-import {} from 'remult';
 export class BaseEnum {
     id;
     caption;
@@ -15,7 +14,4 @@ export class BaseEnum {
             options.icon.caption = options?.caption;
         }
     }
-    getWhere = () => {
-        return this.where ? this.where : this;
-    };
 }

package/esm/FF_Entity.d.ts

@@ -1,2 +1,2 @@
 import { type EntityOptions } from 'remult';
-export declare function FF_Entity<entityType>(key: string, options: EntityOptions<entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType>): (target: any, info?: import("remult/src/remult3/remult3").ClassDecoratorContextStub<entityType extends infer T ? T extends entityType ? T extends new (...args: any) => any ? T : never : never : never> | undefined) => any;
+export declare function FF_Entity<entityType>(key: string, options: EntityOptions<entityType extends new (...args: any) => any ? InstanceType<entityType> : entityType>): (target: any, info?: import("remult/src/remult3/remult3").ClassDecoratorContextStub<entityType extends infer T ? T extends entityType ? T extends new (...args: any) => any ? entityType : never : never : never> | undefined) => any;

package/esm/FF_Entity.js

@@ -1,4 +1,4 @@
-import { Entity } from 'remult';
+import { Entity, isBackend } from 'remult';
 import { recordDeleted, recordSaved } from './changeLog';
 const toAllow = (permission) => {
     if (permission) {
@@ -24,7 +24,9 @@ export function FF_Entity(key, options) {
                 // Don't log changes
             }
             else {
-                await recordSaved(entity, e, options.changeLog);
+                if (isBackend()) {
+                    await recordSaved(entity, e, options.changeLog);
+                }
             }
         },
         deleted: async (entity, e) => {
@@ -33,7 +35,9 @@ export function FF_Entity(key, options) {
                 // Don't log changes
             }
             else {
-                await recordDeleted(entity, e, options.changeLog);
+                if (isBackend()) {
+                    await recordDeleted(entity, e, options.changeLog);
+                }
             }
         },
     });

package/esm/ROUTES.d.ts

@@ -7,7 +7,7 @@ type ParamValue = string | number | undefined;
 /**
  * Append search params to a string
  */
-export declare const appendSp: (sp?: Record<string, ParamValue | ParamValue[]>, prefix?: '?' | '&') => string;
+export declare const appendSp: (sp?: Record<string, ParamValue | ParamValue[]>, prefix?: "?" | "&") => string;
 /**
  * get the current search params
  *
@@ -41,7 +41,7 @@ declare const AllObjs: {
 };
 type AllTypes = typeof AllObjs;
 export type Routes = keyof AllTypes extends `${string}/${infer Route}` ? `/${Route}` : keyof AllTypes;
-export declare const routes: ("/" | "/auth" | "/mail" | "/ui/dialog" | "/ui/enum" | "/ui/fieldGroup" | "/ui/select" | "firstly_sign_in" | "remult_admin" | "github")[];
+export declare const routes: Routes[];
 /**
  * To be used like this:
  * ```ts

package/esm/api/index.d.ts

@@ -1,5 +1,4 @@
-/// <reference types=".pnpm/@sveltejs+kit@2.5.24_@sveltejs+vite-plugin-svelte@3.1.2_svelte@4.2.18_vite@5.4.1_@types+node@_lnml5jetshdinsnlj53joqxhde/node_modules/@sveltejs/kit" />
-import { type Handle, type MaybePromise, type RequestEvent } from '@sveltejs/kit';
+import type { Handle, RequestEvent } from '@sveltejs/kit';
 import { type ClassType } from 'remult';
 import type { RemultServerOptions } from 'remult/server';
 import { type MailOptions } from '../mail';
@@ -15,7 +14,7 @@ export type Module = {
     initRequest?: RemultServerOptions<RequestEvent>['initRequest'];
     handlePreRemult?: Handle;
     handlePosRemult?: Handle;
-    earlyReturn?: (input: Parameters<Handle>[0]) => MaybePromise<{
+    earlyReturn?: (input: Parameters<Handle>[0]) => Promise<{
         early: false;
         resolve?: undefined;
     } | {

package/esm/api/index.js

@@ -1,4 +1,3 @@
-import {} from '@sveltejs/kit';
 import nodemailer from 'nodemailer';
 import { remult } from 'remult';
 import { remultSveltekit } from 'remult/remult-sveltekit';
@@ -23,9 +22,10 @@ export const firstly = (o) => {
             error: o.error
                 ? o.error
                 : async (e) => {
-                    // if 500 we move to 501 to avoid the default retry mechanism
-                    if (e.httpStatusCode == 500) {
-                        e.sendError(501, e.responseBody);
+                    // REMULT P2: validation error should probably be 409
+                    // if 400 we move to 409
+                    if (e.httpStatusCode == 400) {
+                        e.sendError(409, e.responseBody);
                     }
                 },
             // Add user configuration

package/esm/auth/RoleHelpers.d.ts

@@ -9,4 +9,4 @@ export declare const mergeRoles: (existing: string[], newOnes: string[] | undefi
     roles: string[];
     changed: boolean;
 };
-export declare const initRoleFromEnv: (log: Log, userEntity: ClassType<FFAuthUser>, envValue: string | undefined, role: string) => Promise<void>;
+export declare const initRoleFromEnv: (log: Log, userEntity: ClassType<FFAuthUser>, envKey: string, role: string) => Promise<void>;

package/esm/auth/RoleHelpers.js

@@ -1,5 +1,6 @@
 import { repo } from 'remult';
 import { cyan, green, Log, yellow } from '@kitql/helpers';
+import { env } from '$env/dynamic/private';
 import { FFAuthUser } from './client/Entities';
 /**
  * will merge the roles and remove duplicates
@@ -16,7 +17,8 @@ export const mergeRoles = (existing, newOnes) => {
     }
     return { roles: Array.from(result), changed };
 };
-export const initRoleFromEnv = async (log, userEntity, envValue, role) => {
+export const initRoleFromEnv = async (log, userEntity, envKey, role) => {
+    const envValue = envKey ? env[envKey] : '';
     const identifiers = envValue === undefined ? [] : (envValue ?? '').split(',').map((c) => c.trim());
     for (let i = 0; i < identifiers.length; i++) {
         const identifier = identifiers[i].trim();
@@ -35,9 +37,9 @@ export const initRoleFromEnv = async (log, userEntity, envValue, role) => {
         }
     }
     if (identifiers.length > 0) {
-        log.info(`${cyan(role)}: ${identifiers.map((c) => green(c.trim())).join(', ')} added via ${yellow(`.env`)}.`);
+        log.info(`${cyan(envKey)}: ${identifiers.map((c) => green(c.trim())).join(', ')} added via ${yellow(`.env`)}.`);
     }
     else {
-        log.info(`${cyan(role)}: No users added via ${yellow(`.env`)}.`);
+        log.info(`${cyan(envKey)}: No users added via ${yellow(`.env`)}.`);
     }
 };

package/esm/auth/client/Auth.js

@@ -4,7 +4,7 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
     else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
     return c > 3 && r && Object.defineProperty(target, key, r), r;
 };
-import { BackendMethod } from 'remult';
+import { Allow, BackendMethod } from 'remult';
 export class Auth {
     // Do not show for firstly users ?
     /** DO NOT USE */
@@ -104,7 +104,7 @@ __decorate([
     BackendMethod({ allowed: true })
 ], Auth, "signInDemo", null);
 __decorate([
-    BackendMethod({ allowed: true })
+    BackendMethod({ allowed: Allow.authenticated })
 ], Auth, "invite", null);
 __decorate([
     BackendMethod({ allowed: true })

package/esm/auth/client/Entities.d.ts

@@ -1,7 +1,7 @@
 import { BaseEnum } from '../..';
 import type { BaseEnumOptions } from '../..';
-export declare const FF_Auth_Role: {
-    readonly Admin: "FF_Auth_Role.Admin";
+export declare const FF_Role_Auth: {
+    readonly Admin: "FF_Role_Auth.Admin";
 };
 export declare class FFAuthUser {
     id: string;

package/esm/auth/client/Entities.js

@@ -7,8 +7,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 var FFAuthProvider_1;
 import { Fields, Relations, Validators, ValueListFieldType } from 'remult';
 import { BaseEnum, FF_Entity, FF_Role } from '../..';
-export const FF_Auth_Role = {
-    Admin: 'FF_Auth_Role.Admin',
+export const FF_Role_Auth = {
+    Admin: 'FF_Role_Auth.Admin',
 };
 let FFAuthUser = class FFAuthUser {
     id;
@@ -65,7 +65,7 @@ __decorate([
 ], FFAuthUser.prototype, "sessions", void 0);
 FFAuthUser = __decorate([
     FF_Entity('ff_auth.users', {
-        allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
+        allowApiCrud: [FF_Role_Auth.Admin, FF_Role.Admin],
         caption: 'FF Auth - Users',
     })
 ], FFAuthUser);
@@ -118,7 +118,7 @@ __decorate([
 ], FFAuthAccount.prototype, "lastVerifiedAt", void 0);
 FFAuthAccount = __decorate([
     FF_Entity('ff_auth.accounts', {
-        allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
+        allowApiCrud: [FF_Role_Auth.Admin, FF_Role.Admin],
         caption: 'FF Auth - Accounts',
         // id: { provider: true, userId: true },
         changeLog: {
@@ -149,7 +149,7 @@ __decorate([
 ], FFAuthUserSession.prototype, "user", void 0);
 FFAuthUserSession = __decorate([
     FF_Entity('ff_auth.users_sessions', {
-        allowApiCrud: [FF_Auth_Role.Admin, FF_Role.Admin],
+        allowApiCrud: [FF_Role_Auth.Admin, FF_Role.Admin],
         caption: 'FF Auth - Users sessions',
         changeLog: false,
     })

package/esm/auth/client/index.d.ts

@@ -2,6 +2,6 @@ import { Log } from '@kitql/helpers';
 import { Auth } from './Auth';
 import { FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession } from './Entities';
 export declare const logAuth: Log;
-export { FF_Auth_Role } from './Entities';
+export { FF_Role_Auth } from './Entities';
 export { Auth };
 export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };

package/esm/auth/client/index.js

@@ -2,6 +2,6 @@ import { Log } from '@kitql/helpers';
 import { Auth } from './Auth';
 import { FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession } from './Entities';
 export const logAuth = new Log('firstly | auth');
-export { FF_Auth_Role } from './Entities';
+export { FF_Role_Auth } from './Entities';
 export { Auth };
 export { FFAuthUser, FFAuthAccount, FFAuthProvider, FFAuthUserSession };

package/esm/auth/index.d.ts

@@ -4,6 +4,7 @@ import type { ClassType, UserInfo } from 'remult';
 import type { Module } from '../api';
 import type { RecursivePartial, ResolvedType } from '../utils/types';
 import { FFAuthAccount, FFAuthUser, FFAuthUserSession } from './client/Entities';
+import { initRoleFromEnv } from './RoleHelpers';
 import type { firstlyData, firstlyDataAuth } from './types';
 export type { firstlyData };
 export type AuthorizationURLOptions = Record<string, {
@@ -129,6 +130,7 @@ export declare const getSafeOptions: () => {
  * _Info: index: -777_
  */
 export declare const auth: (o: AuthOptions) => Module;
+export { initRoleFromEnv };
 export declare let lucia: Lucia<Record<any, any>, UserInfo>;
 declare module 'lucia' {
     interface Register {

package/esm/auth/index.js

@@ -4,12 +4,11 @@ import { Lucia, TimeSpan } from 'lucia';
 import { remult } from 'remult';
 import { red } from '@kitql/helpers';
 import { getRelativePackagePath, read } from '@kitql/internals';
-import { env } from '$env/dynamic/private';
 import { FF_Role } from '../';
 import { RemultLuciaAdapter } from './Adapter';
 import { AuthControllerServer } from './AuthController.server';
 import { Auth, logAuth } from './client';
-import { FF_Auth_Role, FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession, } from './client/Entities';
+import { FF_Role_Auth, FFAuthAccount, FFAuthProvider, FFAuthUser, FFAuthUserSession, } from './client/Entities';
 import { createOrExtendSession } from './helper';
 import { initRoleFromEnv } from './RoleHelpers';
 export let AUTH_OPTIONS = { ui: {} };
@@ -24,7 +23,7 @@ const buildUrlOrDefault = (base, userSetting, fallback) => {
 };
 export const getSafeOptions = () => {
     const signUp = AUTH_OPTIONS.signUp ?? true;
-    const base = AUTH_OPTIONS.ui === false ? 'NO_BASE_PATH' : AUTH_OPTIONS.ui?.paths?.base ?? '/ff/auth';
+    const base = AUTH_OPTIONS.ui === false ? 'NO_BASE_PATH' : (AUTH_OPTIONS.ui?.paths?.base ?? '/ff/auth');
     const firstlyData = {
         module: 'auth',
         debug: AUTH_OPTIONS.debug,
@@ -150,14 +149,25 @@ export const auth = (o) => {
         entities: [oSafe.User, oSafe.Session, oSafe.Account],
         controllers: [Auth],
         initRequest: async (event) => {
-            // std session
-            const sessionId = event.cookies.get(lucia.sessionCookieName);
-            if (sessionId) {
-                const { session, user } = await lucia.validateSession(sessionId);
-                if (session && session.fresh) {
-                    await createOrExtendSession(session.id, session);
+            // REMULT: storing user in local should probably be done in remult directly
+            if (event?.locals?.user) {
+                // console.log('initRequest OK')
+                remult.user = event.locals.user;
+            }
+            else {
+                // console.log('initRequest WORK...')
+                // std session
+                const sessionId = event.cookies.get(lucia.sessionCookieName);
+                if (sessionId) {
+                    const { session, user } = await lucia.validateSession(sessionId);
+                    if (session && session.fresh) {
+                        await createOrExtendSession(session.id, session);
+                    }
+                    remult.user = user ?? undefined;
+                    if (event.locals) {
+                        event.locals.user = user ?? undefined;
+                    }
                 }
-                remult.user = user ?? undefined;
             }
         },
         earlyReturn: async ({ event, resolve }) => {
@@ -296,10 +306,11 @@ export const auth = (o) => {
             return { early: false };
         },
         initApi: async () => {
-            await initRoleFromEnv(logAuth, oSafe.User, env.FF_ADMIN, FF_Role.Admin);
-            await initRoleFromEnv(logAuth, oSafe.User, env.FF_AUTH_ADMIN, FF_Auth_Role.Admin);
+            await initRoleFromEnv(logAuth, oSafe.User, 'FF_ROLE_ADMIN', FF_Role.Admin);
+            await initRoleFromEnv(logAuth, oSafe.User, 'FF_ROLE_AUTH_ADMIN', FF_Role_Auth.Admin);
         },
     };
 };
+export { initRoleFromEnv };
 // Maybe moving this to /auth/server.ts would be better, people will be able to import from firstly all the time
 export let lucia;

package/esm/cellsBuildor.d.ts

@@ -1,10 +1,10 @@
 import type { SvelteComponent } from 'svelte';
-import { type EntityFilter, type FieldMetadata, type Repository } from 'remult';
+import { type ClassType, type EntityFilter, type FieldMetadata, type Repository } from 'remult';
 import type { UnArray } from './utils/types.js';
 export type VisibilityMode = 'view' | 'edit' | 'hide';
 type CellInternal<Entity> = {
     col?: keyof Entity;
-    kind?: 'field' | 'field_link' | 'entity_link' | 'slot' | 'header' | 'component';
+    kind?: 'field' | 'field_link' | 'entity_link' | 'slot' | 'header' | 'component' | 'baseItem';
     class?: string;
     header?: string;
     headerSlot?: boolean;
@@ -40,7 +40,7 @@ export declare function cellsBuildor<Entity>(repo: Repository<Entity>, inputBuil
 export declare function cellBuildor<Entity>(repo: Repository<Entity>, inputBuildor: UnArray<CellsInput<Entity>>): Cell<Entity>;
 export declare const fieldsOf: <Entity>(b: Cell<Entity>[]) => FieldMetadata<any, Entity>[];
 export declare const getPlaceholder: <Entity>(fields: FieldMetadata<any, Entity>[]) => string;
-export declare const buildSearchWhere: <Entity>(entity: Entity | undefined, fields: FieldMetadata<any, Entity>[], search?: string | null) => EntityFilter<Entity>[];
+export declare const buildSearchWhere: <Entity>(entity: ClassType<Entity> | undefined, fields: FieldMetadata<any, Entity>[], search?: string | null) => EntityFilter<Entity>[];
 export declare const containsWords: <Entity>(fields: FieldMetadata<any, Entity>[], search: string) => EntityFilter<Entity>;
-export declare const buildWhere: <Entity>(entity: Entity | undefined, defaultWhere: EntityFilter<Entity> | undefined, fields_filter: FieldMetadata<any, Entity>[], fields_search: FieldMetadata<any, Entity>[], obj: Record<string, string>) => EntityFilter<Entity>;
+export declare const buildWhere: <Entity>(entity: ClassType<Entity> | undefined, defaultWhere: EntityFilter<Entity> | undefined, fields_filter: FieldMetadata<any, Entity>[], fields_search: FieldMetadata<any, Entity>[], obj: Record<string, string>) => EntityFilter<Entity>;
 export {};

package/esm/cellsBuildor.js

@@ -77,7 +77,7 @@ export const buildSearchWhere = (entity, fields, search) => {
     return f;
 };
 export const containsWords = (fields, search) => {
-    const sSplitted = search.split(' ');
+    const sSplitted = search.split(' ').filter((s) => s.length > 0);
     if (fields.length === 1) {
         return {
             $and: sSplitted.map((s) => ({ [fields[0].key]: { $contains: s } })),
@@ -106,12 +106,25 @@ export const buildWhere = (entity, defaultWhere, fields_filter, fields_search, o
                 and.push({ [field.key]: obj[field.key] });
             }
             else if (field.inputType === 'selectEnum') {
+                const fnName = field.key + 'Filter';
                 // @ts-ignore
-                const theEnum = getEnum(field, obj[field.key]);
-                // Take the where of the enum if it exists, or it's using this selection as a filter
-                const wheretoUse = theEnum?.where ?? new BaseEnum(obj[field.key]);
-                // @ts-ignore
-                and.push({ [field.key]: wheretoUse });
+                if (entity && entity[fnName]) {
+                    // @ts-ignore
+                    and.push(entity[fnName](obj[field.key]));
+                }
+                else {
+                    // @ts-ignore
+                    const theEnum = getEnum(field, obj[field.key]);
+                    // Take the where of the enum if it exists, or it's using this selection as a filter
+                    if (theEnum?.where) {
+                        and.push(theEnum.where);
+                    }
+                    else {
+                        const wheretoUse = theEnum?.where ?? new BaseEnum(obj[field.key]);
+                        // @ts-ignore
+                        and.push({ [field.key]: wheretoUse });
+                    }
+                }
             }
             else if (rfi?.type === 'toOne') {
                 // @ts-ignore (setting the id of the relation)

package/esm/feedback/FeedbackController.d.ts

@@ -16,7 +16,7 @@ export declare class FeedbackController {
         state: any;
         items: {
             bodyHTML: string;
-            who?: string | undefined;
+            who?: string;
             createdAt: Date;
             public: boolean;
         }[];

package/esm/feedback/FeedbackController.js

@@ -21,13 +21,11 @@ async function getGitHub(query, variables) {
         const response = await fetch(GITHUB_GRAPHQL_ENDPOINT, { method: 'POST', headers, body });
         const result = await response.json();
         if (result.errors) {
-            /* eslint-disable */
             console.error(`result ERRORS`, body, stry(result));
         }
         return result.data;
     }
     catch (error) {
-        /* eslint-disable */
         console.error(`error`, error);
     }
     return null;

package/esm/feedback/ui/DialogIssue.svelte

@@ -83,11 +83,11 @@ const disableButton = (issueNumber2, title2, content2) => {
             ).toLocaleTimeString()}</time
           >
         </div>
-        <div class="chat-bubble">{@html item.bodyHTML}</div>
+        <div class="chat-bubble prose">{@html item.bodyHTML}</div>
         <!-- <div class="chat-footer opacity-50">Delivered</div> -->
       </div>
     {/each}
-    {#if issue?.highlight}
+    {#if issue?.highlight && issue.state === 'OPEN'}
       <span class="badge badge-warning">En attente de réponse de TA part 😉, oui 🫵!</span>
     {/if}
     {#if issueNumber}
@@ -106,15 +106,15 @@ const disableButton = (issueNumber2, title2, content2) => {
       ></Textarea>
       <div class="flex justify-between">
         {#if issueNumber}
-          <Button on:click={close} tabIndex={-1} class="btn-outline btn-error">
-            Clore le feedback
-          </Button>
+          <Button on:click={close} tabIndex={-1} class="btn-outline btn-error"
+            >Clore le feedback</Button
+          >
         {:else}
           <div></div>
         {/if}
-        <Button on:click={send} disabled={disableButton(issueNumber, title, content)}>
-          Envoyer
-        </Button>
+        <Button on:click={send} disabled={disableButton(issueNumber, title, content)}
+          >Envoyer</Button
+        >
       </div>
     {/if}
   {/if}

package/esm/handle/index.d.ts

@@ -1,4 +1,3 @@
-/// <reference types=".pnpm/@sveltejs+kit@2.5.24_@sveltejs+vite-plugin-svelte@3.1.2_svelte@4.2.18_vite@5.4.1_@types+node@_lnml5jetshdinsnlj53joqxhde/node_modules/@sveltejs/kit" />
 import type { Handle } from '@sveltejs/kit';
 import type { RemultSveltekitServer } from 'remult/remult-sveltekit';
 import type { Module } from '../api';

package/esm/helper.d.ts

@@ -1,19 +1,9 @@
-import type { ClassType, ErrorInfo, FieldMetadata, Repository } from 'remult';
+import type { ClassType, ErrorInfo, FieldMetadata, LifecycleEvent, Repository } from 'remult';
 import type { BaseEnum, BaseItem } from './index.js';
 export declare function isError<T>(object: any): object is ErrorInfo<T>;
 export declare const getFirstInterestingField: <Entity>(repo: Repository<Entity>) => FieldMetadata<any, Entity>;
 export declare const getEntityDisplayValue: <Entity>(repo: Repository<Entity>, row: Entity) => BaseItem;
-export declare const getFieldLinkDisplayValue: (field: FieldMetadata, row: any) => import("./BaseEnum.js").BaseEnumOptions<any> & {
-    id: string;
-    captionSub?: string | (string | undefined)[] | undefined;
-    href?: string | undefined;
-    repo?: Repository<any> | undefined;
-    sub?: {
-        captionPre?: string | undefined;
-        repo?: Repository<any> | undefined;
-        item?: any;
-    } | undefined;
-} & {
+export declare const getFieldLinkDisplayValue: (field: FieldMetadata, row: any) => BaseItem & {
     href: string;
 };
 export declare const getEntityDisplayValueFromField: (field: FieldMetadata, row: any) => BaseItem & {
@@ -43,6 +33,18 @@ type MetaTypeSlot = {
 export type FieldMetaType = MetaTypeRelation | MetaTypeEnum | MetaTypePrimitive | MetaTypeSlot;
 export declare const getFieldMetaType: (field?: FieldMetadata) => FieldMetaType;
 export declare const displayWithDefaultAndSuffix: (field: FieldMetadata<any, any> | undefined, value: any) => string;
-export declare const getEnum: <T extends BaseEnum<any>>(baseEnum: ClassType<T>, id: string | undefined | null) => T | undefined;
-export declare const getEnums: <T extends BaseEnum<any>>(baseEnum: ClassType<T>) => T[];
+export declare const getEnum: <T extends BaseEnum>(baseEnum: ClassType<T>, id: string | undefined | null) => T | undefined;
+export declare const getEnums: <T extends BaseEnum>(baseEnum: ClassType<T>) => T[];
+export declare const upsert: <Entity>(currentRepo: Repository<Entity>, id: Parameters<typeof currentRepo.findId>[0], entity: Partial<Entity>) => Promise<void>;
+/**
+ * To be used like:
+ * ```ts
+ * \@Entity('tasks', {
+ *   async deleting(item, e) {
+ *     await onDelete(item, e, 'prevent')
+ *   },
+ * }
+ * ```
+ */
+export declare const onDelete: <T>(item: T, e: LifecycleEvent<T>, mode?: "prevent" | "cascade") => Promise<void>;
 export {};

package/esm/helper.js

@@ -1,5 +1,6 @@
 import { getEntityRef, getValueList } from 'remult';
 import { getRelationFieldInfo } from 'remult/internals';
+import { stryEq } from '@kitql/helpers';
 import { suffixWithS } from './formats/strings.js';
 export function isError(object) {
     return object;
@@ -22,7 +23,8 @@ export const getEntityDisplayValue = (repo, row) => {
     }
     const field = getFirstInterestingField(repo);
     // REMULT P3 JYC: If it's an enum, it's not working...
-    return { caption: row ? field.displayValue(row) : '-', id: '' };
+    // @ts-ignore (added for row?.id)
+    return { caption: row ? field.displayValue(row) : '-', id: row?.id ? row.id : '' };
 };
 export const getFieldLinkDisplayValue = (field, row) => {
     const caption = field.displayValue(row);
@@ -89,7 +91,7 @@ export const displayWithDefaultAndSuffix = (field, value) => {
     }
     else {
         // toRet.push(value ?? '-')
-        toRet.push(field?.displayValue ? field?.displayValue({ [field.key]: value }) : value ?? '-');
+        toRet.push(field?.displayValue ? field?.displayValue({ [field.key]: value }) : (value ?? '-'));
     }
     if (value === undefined || value === null) {
         return '';
@@ -117,3 +119,57 @@ export const getEnum = (baseEnum, id) => {
 export const getEnums = (baseEnum) => {
     return getValueList(baseEnum) || [];
 };
+export const upsert = async (currentRepo, id, entity) => {
+    const found = await currentRepo.findId(id);
+    if (found) {
+        // @ts-ignore
+        if (!stryEq(found, entity)) {
+            // Opti => Sedn only the diff?
+            await currentRepo.update(id, entity);
+        }
+    }
+    else {
+        await currentRepo.insert(entity);
+    }
+};
+/**
+ * To be used like:
+ * ```ts
+ * \@Entity('tasks', {
+ *   async deleting(item, e) {
+ *     await onDelete(item, e, 'prevent')
+ *   },
+ * }
+ * ```
+ */
+export const onDelete = async (item, e, mode = 'prevent') => {
+    const toManies = e.repository.fields
+        .toArray()
+        .map((f) => {
+        return {
+            f: f,
+            fi: getRelationFieldInfo(f),
+        };
+    })
+        .filter((f) => f.fi?.type === 'toMany');
+    const checks = await Promise.all(toManies.map(async (f_fi) => {
+        // @ts-ignore
+        const count = await e.repository.relations(item)[f_fi.f.key].count();
+        return { ...f_fi, count };
+    }));
+    const nonEmptyRelations = checks.filter((check) => check.count > 0);
+    if (nonEmptyRelations.length > 0) {
+        if (mode === 'prevent') {
+            const relationNames = nonEmptyRelations.map((r) => r.f.caption).join(', ');
+            throw Error(`Can't with existing: ${relationNames}`);
+        }
+        else if (mode === 'cascade') {
+            nonEmptyRelations.forEach(async (r) => {
+                const where = Object.entries(r.fi?.getFields().fields ?? {}).map(([key, value]) => {
+                    return { [key]: item[value] };
+                });
+                await r.fi?.toRepo.deleteMany({ where });
+            });
+        }
+    }
+};