SDK v2

inlang/source-code/sdk-v2/src/types/plugin.ts

@@ -8,7 +8,11 @@ import {
 import type { JSONObject } from "@inlang/json-types"
 import type { CustomApiInlangIdeExtension } from "./customApis/app.inlang.ideExtension.js"
 import { Translatable } from "@inlang/translatable"
-import type { ProjectSettings2, ExternalProjectSettings } from "./project-settings.js"
+import {
+	type ProjectSettings2 as ProjectSettings2Type,
+	type ExternalProjectSettings as ExternalProjectSettingsType,
+	ExternalProjectSettings,
+} from "./project-settings.js"
 import type {
 	PluginHasInvalidIdError,
 	PluginHasInvalidSchemaError,
@@ -17,6 +21,8 @@ import type {
 	PluginSaveMessagesFunctionAlreadyDefinedError,
 	PluginsDoNotProvideLoadOrSaveMessagesError,
 } from "./plugin-errors.js"
+import { NestedBundle } from "./schema.js"
+import { TranslationFile, type TranslationFile as TranslationFileType } from "./translation-file.js"
 
 // ---------------------------- RUNTIME VALIDATION TYPES ---------------------------------------------
 
@@ -36,26 +42,24 @@ import type {
  * ```
  */
 export type Plugin2<
-	ExternalSettings extends Record<keyof ExternalProjectSettings, JSONObject> | unknown = unknown
+	ExternalSettings extends Record<keyof ExternalProjectSettingsType, JSONObject> | unknown = unknown
 > = Omit<
 	Static<typeof Plugin2>,
-	"loadMessages" | "saveMessages" | "addCustomApi" | "settingsSchema"
+	"toBeImportedFiles" | "importFiles" | "exportFiles" | "addCustomApi" | "settingsSchema"
 > & {
 	settingsSchema?: TObject
 	/**
-	 * Load messages.
+	 * Import / Export files.
 	 */
-	// TODO SDK-V2 check how to setup loadMessages
-	// loadMessages?: (args: {
-	// 	settings: ProjectSettings2 & ExternalSettings
-	// 	// nodeishFs: NodeishFilesystemSubset
-	// }) => Promise<Message[]> | Message[]
-	// TODO SDK-V2 check how to setup saveMessages
-	// saveMessages?: (args: {
-	// 	// messages: Message[]
-	// 	settings: ProjectSettings2 & ExternalSettings
-	// 	// nodeishFs: NodeishFilesystemSubset
-	// }) => Promise<void> | void
+	toBeImportedFiles?: (args: {
+		settings: ProjectSettings2Type & ExternalSettings
+		nodeFs: unknown
+	}) => Promise<Array<TranslationFileType>> | Array<TranslationFileType>
+	importFiles?: (args: { files: Array<TranslationFileType> }) => { bundles: NestedBundle }
+	exportFiles?: (args: {
+		bundles: NestedBundle
+		settings: ProjectSettings2Type & ExternalSettings
+	}) => Array<TranslationFileType>
 	/**
 	 * Define app specific APIs.
 	 *
@@ -67,7 +71,7 @@ export type Plugin2<
 	 *  })
 	 */
 	addCustomApi?: (args: {
-		settings: ProjectSettings2 & ExternalSettings
+		settings: ProjectSettings2Type & ExternalSettings
 	}) =>
 		| Record<`app.${string}.${string}`, unknown>
 		| { "app.inlang.ideExtension": CustomApiInlangIdeExtension }
@@ -86,8 +90,24 @@ export const Plugin2 = Type.Object({
 	 * https://github.com/opral/monorepo/discussions/1503
 	 */
 	settingsSchema: Type.Optional(Type.Object({}, { additionalProperties: true })),
-	loadMessages: Type.Optional(Type.Any()),
-	saveMessages: Type.Optional(Type.Any()),
+	toBeImportedFiles: Type.Optional(
+		Type.Function(
+			[Type.Object({ settings: ExternalProjectSettings, nodeFs: Type.Any() })],
+			Type.Array(TranslationFile)
+		)
+	),
+	importFiles: Type.Optional(
+		Type.Function(
+			[Type.Object({ files: Type.Array(TranslationFile) })],
+			Type.Object({ bundles: NestedBundle })
+		)
+	),
+	exportFiles: Type.Optional(
+		Type.Function(
+			[Type.Object({ bundles: NestedBundle, settings: ExternalProjectSettings })],
+			Type.Array(TranslationFile)
+		)
+	),
 	/**
 	 * @deprecated removed
 	 */
@@ -100,7 +120,7 @@ export const Plugin2 = Type.Object({
  */
 export type ResolvePlugins2Function = (args: {
 	plugins: Array<Plugin2>
-	settings: ProjectSettings2
+	settings: ProjectSettings2Type
 }) => Promise<{
 	data: ResolvedPlugin2Api
 	errors: Array<
@@ -117,17 +137,9 @@ export type ResolvePlugins2Function = (args: {
  * The API after resolving the plugins.
  */
 export type ResolvedPlugin2Api = {
-	// TODO SDK-V2 check how to setup loadMessages
-	// loadMessages: (args: {
-	// 	settings: ProjectSettings2
-	// 	nodeishFs: NodeishFilesystemSubset
-	// }) => Promise<Message[]> | Message[]
-	// TODO SDK-V2 check how to setup saveMessages
-	// saveMessages: (args: {
-	// 	settings: ProjectSettings2
-	// 	messages: Message[]
-	// 	nodeishFs: NodeishFilesystemSubset
-	// }) => Promise<void> | void
+	toBeImportedFiles: Array<Plugin2["toBeImportedFiles"]>
+	importFiles: Array<Plugin2["importFiles"]>
+	exportFiles: Array<Plugin2["exportFiles"]>
 	/**
 	 * App specific APIs.
 	 *

inlang/source-code/sdk-v2/src/types/schema.ts

@@ -1,113 +1,127 @@
-import type { Insertable, JSONColumnType, Selectable, Updateable } from "kysely"
-
+import { Type, type Static } from "@sinclair/typebox"
+import type { Insertable, Selectable, Updateable } from "kysely"
 import type { LintReport } from "./lint.js"
 
-export type Database = {
-	bundle: BundleTable
-	message: MessageTable
-	variant: VariantTable
-
-	lintReport: LintReport
-	// todo - move out of database
-	settings: Settings
-}
-
-type AliasMap = {
-	[key: string]: string
-}
-
-// Bundles all languages of a message -
-type BundleTable = {
-	id: string
-	// todo make alias relational
-	alias: JSONColumnType<AliasMap> // alias usually have a property "default"  that represents the message name like "welcome_message" or "login_button"
-	// messages[] @relation
-	// messages: Message[]
+export const VariableReference = Type.Object({
+	type: Type.Literal("variable"),
+	name: Type.String(),
+})
+
+export const Literal = Type.Object({
+	type: Type.Literal("literal"),
+	name: Type.String(),
+})
+
+export const Option = Type.Object({
+	name: Type.String(),
+	value: Type.Union([Literal, VariableReference]),
+})
+
+const FunctionAnnotation = Type.Object({
+	type: Type.Literal("function"),
+	name: Type.String(),
+	options: Type.Array(Option),
+})
+
+export const Expression = Type.Object({
+	type: Type.Literal("expression"),
+	arg: Type.Union([VariableReference, Literal]),
+	annotation: Type.Optional(FunctionAnnotation),
+})
+
+export const Text = Type.Object({
+	type: Type.Literal("text"),
+	value: Type.String(),
+})
+
+export const Declaration = Type.Object({
+	type: Type.Literal("input"),
+	name: Type.String(),
+	value: Expression,
+})
+
+export const Pattern = Type.Array(Type.Union([Text, Expression]))
+
+export const Settings = Type.Object({
+	baseLocale: Type.String(),
+	locales: Type.String(),
+	modules: Type.String(),
+})
+
+export const BundleTable = Type.Object({
+	id: Type.String(),
+	alias: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<AliasMap>
+})
+
+export const MessageTable = Type.Object({
+	id: Type.String(),
+	bundleId: Type.String(),
+	locale: Type.String(),
+	declarations: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<Declaration[]>
+	selectors: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<Expression[]>
+})
+
+export const VariantTable = Type.Object({
+	id: Type.String(),
+	messageId: Type.String(),
+	match: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<Record<Expression["arg"]["name"], string>>
+	pattern: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<Pattern>
+})
+
+export const NestedMessage = Type.Object({
+	id: Type.String(),
+	locale: Type.String(),
+	declarations: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<Declaration[]>
+	selectors: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<Expression[]>
+	variants: Type.Array(VariantTable),
+})
+
+export const NestedBundle = Type.Object({
+	id: Type.String(),
+	alias: Type.Any(), // TODO: Use appropriate Typebox type for JSONColumnType<AliasMap>
+	messages: Type.Array(NestedMessage),
+})
+
+// Export types
+export type BundleTableType = Static<typeof BundleTable>
+export type MessageTableType = Static<typeof MessageTable>
+export type VariantTableType = Static<typeof VariantTable>
+
+export type Bundle = Selectable<BundleTableType>
+
+export type NestedMessage = Selectable<MessageTableType> & {
+	variants: Selectable<VariantTableType>[]
 }
 
-type MessageTable = {
-	id: string
-	// @relation to Bundle
-	bundleId: BundleTable["id"]
-	locale: string
-	declarations: JSONColumnType<Declaration[]> // JSON
-	selectors: JSONColumnType<Expression[]> // JSON
-	// variants: Variant[]
-}
-
-type VariantTable = {
-	id: string
-	// @relation to Message
-	messageId: MessageTable["id"]
-	match: JSONColumnType<Record<Expression["arg"]["name"], string>>
-	pattern: JSONColumnType<Pattern> // JSON
-}
-
-export type Bundle = Selectable<BundleTable>
-
-export type NestedMessage = Message & {
-	variants: Variant[]
-}
-
-export type NestedBundle = Bundle & {
+export type NestedBundle = Selectable<BundleTableType> & {
 	messages: NestedMessage[]
 }
 
-export type NewBundle = Insertable<BundleTable>
-export type UpdatedBundle = Updateable<BundleTable>
-
-export type Message = Selectable<MessageTable>
-export type NewMessage = Insertable<MessageTable>
-export type UpdatedMessage = Updateable<MessageTable>
-
-export type Variant = Selectable<VariantTable>
-export type NewVariant = Insertable<VariantTable>
-export type UpdatedVariant = Updateable<VariantTable>
-
-export type Pattern = Array<Text | Expression>
-
-export type Text = {
-	type: "text"
-	value: string
-}
-
-export type VariableReference = {
-	type: "variable"
-	name: string
-}
-
-export type Literal = {
-	type: "literal"
-	name: string
-}
-
-export type Declaration = InputDeclaration
-
-export type InputDeclaration = {
-	type: "input"
-	name: string
-	value: Expression
-}
+export type NewBundle = Insertable<BundleTableType>
+export type UpdatedBundle = Updateable<BundleTableType>
 
-export type Expression = {
-	type: "expression"
-	arg: VariableReference | Literal
-	annotation?: FunctionAnnotation
-}
+export type Message = Selectable<MessageTableType>
+export type NewMessage = Insertable<MessageTableType>
+export type UpdatedMessage = Updateable<MessageTableType>
 
-export type FunctionAnnotation = {
-	type: "function"
-	name: string
-	options: Option[]
-}
+export type Variant = Selectable<VariantTableType>
+export type NewVariant = Insertable<VariantTableType>
+export type UpdatedVariant = Updateable<VariantTableType>
 
-export type Option = {
-	name: string
-	value: Literal | VariableReference
-}
+export type PatternType = Static<typeof Pattern>
+export type TextType = Static<typeof Text>
+export type VariableReferenceType = Static<typeof VariableReference>
+export type LiteralType = Static<typeof Literal>
+export type DeclarationType = Static<typeof Declaration>
+export type ExpressionType = Static<typeof Expression>
+export type FunctionAnnotationType = Static<typeof FunctionAnnotation>
+export type OptionType = Static<typeof Option>
+export type SettingsType = Static<typeof Settings>
 
-export type Settings = {
-	baseLocale: string
-	locales: string
-	modules: string
+export type Database = {
+	bundle: Static<typeof BundleTable>
+	message: Static<typeof MessageTable>
+	variant: Static<typeof VariantTable>
+	lintReport: LintReport
+	settings: Static<typeof Settings>
 }

inlang/source-code/sdk-v2/src/types/translation-file.ts

@@ -0,0 +1,9 @@
+import { Type, type Static } from "@sinclair/typebox"
+
+export const TranslationFile = Type.Object({
+	path: Type.String(),
+	content: Type.String(),
+	pluginKey: Type.String(),
+})
+
+export type TranslationFile = Static<typeof TranslationFile>