@nice2dev/ui-forms 1.4.5 → 1.4.7

package/dist/index.d.ts

@@ -8,6 +8,9 @@ import { NiceDataSourceSchemaTable } from '@nice2dev/ui';
 import { NiceFieldValidationRule } from '@nice2dev/ui';
 import { NiceFormItem } from '@nice2dev/ui';
 import { NiceHookBinding } from '@nice2dev/ui';
+import { NiceModuleDataSource } from '@nice2dev/ui';
+import { NiceNoCodeIo } from '@nice2dev/ui';
+import { NiceNoCodeStep } from '@nice2dev/ui';
 import { NiceRbacModel } from '@nice2dev/ui';
 import { NiceScriptRunnerProps } from '@nice2dev/ui';
 import { NiceStandardProps } from '@nice2dev/ui';
@@ -58,12 +61,12 @@ export declare function defineManifestSection<TSchema extends JsonSchema>(sectio
 
 /** A starter access model: admin / user × view / create / edit / delete over the module's views and entities. */
 export declare function deriveDefaultRbac(module: {
-    manifest?: Row;
+    manifest?: Row_2;
     views?: ReadonlyArray<{
         id: string;
         name: string;
     }>;
-    entities?: readonly Row[];
+    entities?: readonly Row_2[];
 }): NiceRbacModel;
 
 /** Reads how `text` is written: BOM, line breaks, indentation, final newline, colon spacing. */
@@ -82,7 +85,7 @@ export declare function encodeDocument(doc: NiceStudioDocument, model: unknown,
 export declare const endsWithAny: (...suffixes: string[]) => (path: string) => boolean;
 
 /** The module's entities as the tables NiceDataSourceBuilder queries. */
-export declare function entitiesToSchemas(entities: readonly Row[]): NiceDataSourceSchemaTable[];
+export declare function entitiesToSchemas(entities: readonly Row_2[]): NiceDataSourceSchemaTable[];
 
 /** The file name of a path. */
 export declare const fileName: (path: string) => string;
@@ -222,12 +225,21 @@ export declare interface FormSectionDefinition {
     fields: FormFieldDefinition[];
 }
 
+/** A list item back as the stored script: its definition merged onto the entry as stored. */
+export declare function fromStudioScriptItem(item: NiceStudioItem<NiceStudioScriptDef>): unknown;
+
 /**
  * Translations split into one file per language, edited as one document. A new language gets a
  * file shaped and formatted like its siblings; a language removed in the editor loses its file.
  */
 export declare function i18nFileKind(o?: NiceI18nFileKindOptions): NiceStudioFileKind<NiceStudioTranslations>;
 
+/**
+ * The kind of a stored script: its `kind`, else from what it holds — no-code steps, a SQL language
+ * or `sql` text, a C# language (server) — else browser code.
+ */
+export declare function inferStudioScriptKind(raw: Row): NiceStudioScriptKind;
+
 /** Whether a layout holds nothing (its file can go). */
 export declare const isEmptyStudioLayout: (layout: NiceStudioLayout) => boolean;
 
@@ -314,7 +326,7 @@ export declare function modulePrefix(files: readonly NiceStudioFile[]): string;
 
 export declare const nativeDataSourcesKind: NiceStudioFileKind<NiceDataSourceDef[]>;
 
-export declare const nativeEntitiesKind: NiceStudioFileKind<Row_2[]>;
+export declare const nativeEntitiesKind: NiceStudioFileKind<Row_3[]>;
 
 /** The file kinds of the native format, in matching order. */
 export declare const nativeFileKinds: NiceStudioFileKind[];
@@ -323,17 +335,29 @@ export declare const nativeHooksKind: NiceStudioFileKind<NiceHookBinding[]>;
 
 export declare const nativeI18nKind: NiceStudioFileKind<NiceStudioTranslations>;
 
-export declare const nativeManifestKind: NiceStudioFileKind<Row_2>;
+export declare const nativeManifestKind: NiceStudioFileKind<Row_3>;
 
 export declare const nativeRbacKind: NiceStudioFileKind<NiceRbacModel>;
 
-/** The studio's own format: manifest, entities, translations, views, workflows, data sources, access, hooks. */
+/** `{id}.scripts.json`: `{ scripts: [...], phases: { postInstall: [...] } }` (1.4.6). */
+export declare const nativeScriptsKind: NiceStudioFileKind<NiceStudioScripts>;
+
+/** The studio's own format: manifest, entities, translations, views, workflows, data sources, access, hooks, scripts. */
 export declare const nativeStudioPreset: NiceStudioPreset;
 
 export declare const nativeViewsKind: NiceStudioFileKind<NiceStudioItem<NiceViewDefinition>[]>;
 
 export declare const nativeWorkflowsKind: NiceStudioFileKind<NiceStudioItem<NiceWorkflowDefinition>[]>;
 
+/** A new script of a kind, with a starting body in its language. */
+export declare function newStudioScript(spec: NiceStudioNewScript): NiceStudioScriptDef;
+
+/** The script kinds, in the order "Add script" offers them. */
+export declare const NICE_STUDIO_SCRIPT_KINDS: readonly NiceStudioScriptKind[];
+
+/** Install phases offered for database scripts when the preset names none. */
+export declare const NICE_STUDIO_SCRIPT_PHASES: readonly string[];
+
 /** A generated field, as an AI form generator describes it. */
 export declare interface NiceAIFormFieldLike {
     id?: string;
@@ -430,6 +454,16 @@ export declare interface NiceDevelopmentStudioProps extends NiceStandardProps {
     reviewBeforeSave?: boolean;
     /** Runs script files (`script` documents) in a NiceScriptRunner. */
     scriptRunner?: Omit<NiceScriptRunnerProps, 'value' | 'onChange'>;
+    /**
+     * The host's data for a module's no-code scripts (1.4.6): with it the script editor's Run runs
+     * the steps against it (`read` a data source, `write` rows, `callScript`).
+     */
+    scriptIo?: (module: NiceStudioModuleKey) => NiceNoCodeIo | undefined;
+    /**
+     * Runs a data source with parameter values for the designer's Preview (1.4.7) — the host's API
+     * (OmniVerk: `POST /api/data-sources/preview`); a nested list's rows come assembled.
+     */
+    previewDataSource?: NiceStudioPreviewDataSource;
     /** The host's own preview of a view (e.g. its runtime renderer): small in the preview, full beside the designer. */
     renderViewPreview?: (ctx: NiceStudioViewPreviewContext) => React.ReactNode;
     /** Extra parts of a module (payments, webhooks, …): rows under the module, opened full-screen. */
@@ -724,6 +758,22 @@ export declare interface NiceSchemaFormProps extends NiceStandardProps {
     tutorial?: NiceComponentTutorial;
 }
 
+/** Options of {@link scriptsFileKind}. */
+export declare interface NiceScriptsFileKindOptions {
+    id?: string;
+    label?: string;
+    labelKey?: string;
+    icon?: string;
+    match(path: string): boolean;
+    /** The property holding the scripts list. Default `scripts`; the file may also be the bare list. */
+    property?: string;
+    /**
+     * The property holding the database scripts per phase. Default `phases`. The same as `property`:
+     * that property holds either — a list of scripts or an object of phases (OmniVerk).
+     */
+    phasesProperty?: string;
+}
+
 /** A host's own action in the studio's tree header (e.g. "Open a folder…"). */
 export declare interface NiceStudioAction {
     key: string;
@@ -735,7 +785,9 @@ export declare interface NiceStudioAction {
 }
 
 /** The studio's own editors. */
-export declare type NiceStudioBuiltinEditorId = 'manifest' | 'entities' | 'i18n' | 'views' | 'workflows' | 'permissions' | 'rbac' | 'dataSources' | 'seeds' | 'hooks' | 'script' | 'json' | 'text';
+export declare type NiceStudioBuiltinEditorId = 'manifest' | 'entities' | 'i18n' | 'views' | 'workflows' | 'permissions' | 'rbac' | 'dataSources' | 'seeds' | 'hooks' | 'script'
+/** A list of named scripts and database scripts per phase ({@link NiceStudioScripts}, 1.4.6). */
+| 'scriptList' | 'json' | 'text';
 
 /** What a file kind's decode and encode know about the module. */
 export declare interface NiceStudioCodecContext {
@@ -989,6 +1041,16 @@ export declare interface NiceStudioModuleSpec {
     permissions?: boolean;
 }
 
+/** What "Add script" asks for. */
+export declare interface NiceStudioNewScript {
+    kind: NiceStudioScriptKind;
+    /** The display name; the script's `name` is made from it. */
+    name: string;
+    language?: string;
+    category?: string;
+    trigger?: string;
+}
+
 /** A group of modules in a workspace (a category, a product line). */
 export declare interface NiceStudioPackage {
     id: string;
@@ -1061,6 +1123,8 @@ export declare interface NiceStudioPreset {
         path: string;
         text: string;
     } | undefined;
+    /** Kinds, categories, triggers and phases of the module's scripts (1.4.6). */
+    scripts?: NiceStudioScriptOptions;
     /** Lifecycle triggers offered by a `hooks` document. */
     hooks?: {
         triggers: Array<{
@@ -1079,6 +1143,12 @@ export declare interface NiceStudioPreset {
     templateSchema?: JsonSchema;
 }
 
+/**
+ * Runs a module's data source with parameter values for the data source editor's Preview (1.4.7) —
+ * the host's API (OmniVerk: `POST /api/data-sources/preview`), a mock in a demo.
+ */
+export declare type NiceStudioPreviewDataSource = (module: NiceStudioModuleKey, def: NiceModuleDataSource, params: Record<string, string>) => Promise<ReadonlyArray<Record<string, unknown>>>;
+
 /**
  * How the studio reaches the host's modules. Only the four list/read/write methods are needed;
  * each optional one turns on the matching feature (create, delete, packages, templates,
@@ -1132,6 +1202,73 @@ export declare interface NiceStudioRevision {
     path?: string;
 }
 
+/** A named script of a module (1.4.6). Fields the studio does not edit stay in the stored entry. */
+export declare interface NiceStudioScriptDef {
+    id?: string;
+    /** The name other scripts and the app call it by (unique in the module). */
+    name: string;
+    displayName?: string;
+    description?: string;
+    kind: NiceStudioScriptKind;
+    /** `typescript`, `javascript`, `csharp`, `sql`… (none for a no-code script). */
+    language?: string;
+    /** Free grouping: `formatting`, `validation`, `integration`… */
+    category?: string;
+    /** What runs it: an event, a schedule, a button (one of the preset's `scripts.triggers`). */
+    trigger?: string;
+    parameters?: NiceStudioScriptParameter[];
+    returnType?: string;
+    /** The code (frontend, backend, SQL). */
+    source?: string;
+    /** A file of the module holding the code instead of `source`. */
+    sourcePath?: string;
+    /** The steps of a no-code script. */
+    steps?: NiceNoCodeStep[];
+}
+
+/**
+ * What a script is (1.4.6): code run in the browser (`frontend`), code run on the server
+ * (`backend`), no-code steps (`noCode`, run by `runNoCodeScript`) or a SQL query or procedure.
+ */
+export declare type NiceStudioScriptKind = 'frontend' | 'backend' | 'noCode' | 'sql';
+
+/** How a preset's scripts look (1.4.6). */
+export declare interface NiceStudioScriptOptions {
+    /** The kinds "Add script" offers. Default: all four. */
+    kinds?: NiceStudioScriptKind[];
+    /** Categories offered (the module's own are offered too). */
+    categories?: string[];
+    /** What can run a script. */
+    triggers?: Array<{
+        id: string;
+        label: string;
+        description?: string;
+    }>;
+    /** Install phases offered for database scripts. Default: preInstall, postInstall, preUninstall, postUninstall. */
+    phases?: string[];
+}
+
+/** A parameter of a script. */
+export declare interface NiceStudioScriptParameter {
+    name: string;
+    /** Its type as the script's language writes it (`string`, `Date | string`, `decimal`). */
+    type?: string;
+    description?: string;
+    default?: unknown;
+}
+
+/** The model of the `scriptList` editor (1.4.6): named scripts and database scripts per phase. */
+export declare interface NiceStudioScripts {
+    scripts: Array<NiceStudioItem<NiceStudioScriptDef>>;
+    /** SQL statements per install phase: `{ postInstall: ['CREATE INDEX …'] }`. */
+    phases?: Record<string, string[]>;
+    /**
+     * What the file can hold when one property keeps either (OmniVerk's `scripts` is a list of
+     * scripts or an object of phases): only named scripts, or only phases. Absent: both.
+     */
+    holds?: 'scripts' | 'phases';
+}
+
 /** The model of the `seeds` editor: rows per entity, plus demo rows. */
 export declare interface NiceStudioSeeds {
     seeds: Record<string, Array<Record<string, unknown>>>;
@@ -1263,12 +1400,21 @@ declare type Row = Record<string, unknown>;
 
 declare type Row_2 = Record<string, unknown>;
 
+declare type Row_3 = Record<string, unknown>;
+
 /** Parses JSON without a BOM and returns `fallback` when the text is not JSON. */
 export declare function safeJson<T = unknown>(text: string, fallback: T): T;
 
 /** Convert a FormSchema into DevExtreme-style form items. */
 export declare function schemaToFormItems(schema: FormSchema): any[];
 
+/**
+ * A file of named scripts and database scripts per phase (the `scriptList` editor). Scripts the
+ * form does not understand stay raw and round-trip as they are; a file whose phases are not lists
+ * of SQL text opens as raw JSON.
+ */
+export declare function scriptsFileKind(o: NiceScriptsFileKindOptions): NiceStudioFileKind<NiceStudioScripts>;
+
 /** A layout's file text: two-space JSON with a final newline, in the line ending of `previous`. */
 export declare function serializeStudioLayout(layout: NiceStudioLayout, previous?: string): string;
 
@@ -1287,9 +1433,18 @@ export declare const studioEntryRef: (group: string, key: string) => string;
  */
 export declare function studioLayoutPath(files: readonly NiceStudioFile[]): string;
 
+/** `"Send invoice"` → `sendInvoice`: a name usable as a function's. */
+export declare function studioScriptIdentifier(name: string): string;
+
+/** The languages of a kind, the first being the default (none for no-code). */
+export declare function studioScriptLanguages(kind: NiceStudioScriptKind): string[];
+
 /** Any other file, edited as text. */
 export declare const textFallbackKind: NiceStudioFileKind<string>;
 
+/** A stored script as a list item: with a definition when the form can keep every field it edits. */
+export declare function toStudioScriptItem(raw: unknown, index: number): NiceStudioItem<NiceStudioScriptDef>;
+
 /**
  * Validate a value object against a (subset of) Draft-07 JSON Schema.
  * Covers required, type, enum, minLength/maxLength, minimum/maximum and pattern.