@ronin/compiler 0.14.13 → 0.14.14-leo-ron-1099-1-experimental-357

package/dist/index.d.ts

@@ -95,7 +95,7 @@ type OrderedByInstruction = {
     ascending?: Array<string | Expression>;
     descending?: Array<string | Expression>;
 };
-type ForInstruction = Array<string> | Record<string, string>;
+type UsingInstruction = Array<string> | Record<string, string>;
 type CombinedInstructions = {
     with?: WithInstruction | Array<WithInstruction>;
     to?: FieldSelector;
@@ -105,15 +105,15 @@ type CombinedInstructions = {
     before?: string | null;
     after?: string | null;
     limitedTo?: number;
-    for?: ForInstruction;
+    using?: UsingInstruction;
 };
-type InstructionSchema = 'with' | 'to' | 'including' | 'selecting' | 'orderedBy' | 'orderedBy.ascending' | 'orderedBy.descending' | 'before' | 'after' | 'limitedTo' | 'for';
+type InstructionSchema = 'with' | 'to' | 'including' | 'selecting' | 'orderedBy' | 'orderedBy.ascending' | 'orderedBy.descending' | 'before' | 'after' | 'limitedTo' | 'using';
 type GetQuery = Record<string, Omit<CombinedInstructions, 'to'> | null>;
 type SetQuery = Record<string, Omit<CombinedInstructions, 'to'> & {
     to: FieldSelector;
 }>;
-type AddQuery = Record<string, Omit<CombinedInstructions, 'with' | 'for'> & {
-    to: FieldSelector;
+type AddQuery = Record<string, Omit<CombinedInstructions, 'with' | 'using'> & {
+    with: FieldSelector;
 }>;
 type RemoveQuery = Record<string, Omit<CombinedInstructions, 'to'>>;
 type CountQuery = Record<string, Omit<CombinedInstructions, 'to'> | null>;
@@ -121,7 +121,7 @@ type GetInstructions = Omit<CombinedInstructions, 'to'>;
 type SetInstructions = Omit<CombinedInstructions, 'to'> & {
     to: FieldSelector;
 };
-type AddInstructions = Omit<CombinedInstructions, 'with' | 'for'> & {
+type AddInstructions = Omit<CombinedInstructions, 'with' | 'using'> & {
     to: FieldSelector;
 };
 type RemoveInstructions = Omit<CombinedInstructions, 'to'>;
@@ -132,7 +132,7 @@ type CreateQuery = {
 };
 type AlterQuery = {
     model: string;
-    to?: Partial<PublicModel>;
+    to?: Partial<Omit<PublicModel, 'fields' | 'indexes' | 'triggers' | 'presets' | 'idPrefix'>>;
     create?: {
         field?: ModelField;
         index?: ModelIndex;

package/dist/index.js

@@ -257,8 +257,8 @@ var handleBeforeOrAfter = (model, statementParams, instructions) => {
 };
 
 // src/instructions/for.ts
-var handleFor = (model, instructions) => {
-  const normalizedFor = Array.isArray(instructions.for) ? Object.fromEntries(instructions.for.map((presetSlug) => [presetSlug, null])) : instructions.for;
+var handleUsing = (model, instructions) => {
+  const normalizedFor = Array.isArray(instructions.using) ? Object.fromEntries(instructions.using.map((presetSlug) => [presetSlug, null])) : instructions.using;
   for (const presetSlug in normalizedFor) {
     if (!Object.hasOwn(normalizedFor, presetSlug)) continue;
     const arg = normalizedFor[presetSlug];
@@ -269,28 +269,28 @@ var handleFor = (model, instructions) => {
         code: "PRESET_NOT_FOUND"
       });
     }
-    const replacedForFilter = structuredClone(preset.instructions);
+    const replacedUsingFilter = structuredClone(preset.instructions);
     if (arg !== null) {
       findInObject(
-        replacedForFilter,
+        replacedUsingFilter,
         QUERY_SYMBOLS.VALUE,
         (match) => match.replace(QUERY_SYMBOLS.VALUE, arg)
       );
     }
-    for (const subInstruction in replacedForFilter) {
-      if (!Object.hasOwn(replacedForFilter, subInstruction)) continue;
+    for (const subInstruction in replacedUsingFilter) {
+      if (!Object.hasOwn(replacedUsingFilter, subInstruction)) continue;
       const instructionName = subInstruction;
       const currentValue = instructions[instructionName];
       if (currentValue) {
         let newValue;
         if (Array.isArray(currentValue)) {
           newValue = [
-            ...replacedForFilter[instructionName],
+            ...replacedUsingFilter[instructionName],
             ...currentValue
           ];
         } else if (isObject(currentValue)) {
           newValue = {
-            ...replacedForFilter[instructionName],
+            ...replacedUsingFilter[instructionName],
             ...currentValue
           };
         }
@@ -298,7 +298,7 @@ var handleFor = (model, instructions) => {
         continue;
       }
       Object.assign(instructions, {
-        [instructionName]: replacedForFilter[instructionName]
+        [instructionName]: replacedUsingFilter[instructionName]
       });
     }
   }
@@ -550,7 +550,7 @@ var handleTo = (models, model, statementParams, queryType, dependencyStatements,
         const query = compileQueryInput(
           {
             [subQueryType]: {
-              [associativeModelSlug]: subQueryType === "add" ? { to: recordDetails } : { with: recordDetails }
+              [associativeModelSlug]: { with: recordDetails }
             }
           },
           models,
@@ -615,8 +615,8 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
   const single = queryModel !== model.pluralSlug;
   let instructions = formatIdentifiers(model, queryInstructions);
   const returning = options?.returning ?? true;
-  if (instructions && Object.hasOwn(instructions, "for")) {
-    instructions = handleFor(model, instructions);
+  if (instructions && typeof instructions.using !== "undefined") {
+    instructions = handleUsing(model, instructions);
   }
   if (queryType === "count") {
     if (!instructions) instructions = {};
@@ -673,10 +673,12 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
     statement += `"${model.table}" `;
   }
   if (queryType === "add" || queryType === "set") {
-    if (!isObject(instructions.to) || Object.keys(instructions.to).length === 0) {
+    const instructionName = queryType === "add" ? "with" : "to";
+    const instructionValue = instructions[instructionName];
+    if (!(instructionValue && isObject(instructionValue)) || Object.keys(instructionValue).length === 0) {
       throw new RoninError({
-        message: `When using a \`${queryType}\` query, the \`to\` instruction must be a non-empty object.`,
-        code: "INVALID_TO_VALUE",
+        message: `When using a \`${queryType}\` query, the \`${instructionName}\` instruction must be a non-empty object.`,
+        code: instructionName === "to" ? "INVALID_TO_VALUE" : "INVALID_WITH_VALUE",
         queries: [query]
       });
     }
@@ -686,7 +688,7 @@ var compileQueryInput = (defaultQuery, models, statementParams, options) => {
       statementParams,
       queryType,
       dependencyStatements,
-      { with: instructions.with, to: instructions.to },
+      { with: instructions.with, to: instructionValue },
       options?.parentModel
     );
     statement += `${toStatement} `;
@@ -1719,7 +1721,7 @@ var transformMetaQuery = (models, dependencyStatements, statementParams, query)
         if (!Object.hasOwn(entities, entity2)) continue;
         Object.defineProperty(modelWithObjects, entity2, { value: entities[entity2] });
       }
-      queryTypeDetails = { to: modelWithObjects };
+      queryTypeDetails = { with: modelWithObjects };
       getSystemModels(models, modelWithPresets).map((systemModel) => {
         return handleSystemModel(models, dependencyStatements, "create", systemModel);
       });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ronin/compiler",
-  "version": "0.14.13",
+  "version": "0.14.14-leo-ron-1099-1-experimental-357",
   "type": "module",
   "description": "Compiles RONIN queries to SQL statements.",
   "publishConfig": {